├── .gitignore ├── renders ├── dragon.png ├── bathroom.png ├── staircase.png └── testball.png ├── scenes └── material-testball │ ├── textures │ └── envmap.hdr │ ├── LICENSE.txt │ └── scene.json ├── src ├── math │ ├── ray.rs │ ├── mod.rs │ ├── frame.rs │ ├── aabb.rs │ ├── vec3.rs │ └── mat4.rs ├── geometry.rs ├── warp.rs ├── camera.rs ├── distribution.rs ├── integrator.rs ├── light.rs ├── scene.rs ├── mesh.rs ├── texture.rs ├── obj.rs ├── primitive.rs ├── bvh.rs ├── lib.rs ├── bin │ └── render_tungsten.rs └── material.rs ├── Cargo.toml ├── LICENSE ├── README.md └── examples └── cornell.rs /.gitignore: -------------------------------------------------------------------------------- 1 | target/ 2 | Cargo.lock 3 | -------------------------------------------------------------------------------- /renders/dragon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yblein/tracing/HEAD/renders/dragon.png -------------------------------------------------------------------------------- /renders/bathroom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yblein/tracing/HEAD/renders/bathroom.png -------------------------------------------------------------------------------- /renders/staircase.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yblein/tracing/HEAD/renders/staircase.png -------------------------------------------------------------------------------- /renders/testball.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yblein/tracing/HEAD/renders/testball.png -------------------------------------------------------------------------------- /scenes/material-testball/textures/envmap.hdr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/yblein/tracing/HEAD/scenes/material-testball/textures/envmap.hdr -------------------------------------------------------------------------------- /src/math/ray.rs: -------------------------------------------------------------------------------- 1 | use math::Vec3; 2 | 3 | #[derive(Copy, Clone, Debug)] 4 | pub struct Ray { 5 | pub origin: Vec3, 6 | pub direction: Vec3, 7 | } 8 | 9 | impl Ray { 10 | pub fn point_at(&self, t: f32) -> Vec3 { 11 | self.origin + self.direction * t 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/geometry.rs: -------------------------------------------------------------------------------- 1 | use math::*; 2 | 3 | #[derive(Copy, Clone)] 4 | pub struct Intersection { 5 | pub distance: f32, 6 | pub normal: Vec3, 7 | pub uv: (f32, f32), 8 | } 9 | 10 | pub trait Surface { 11 | fn intersect(&self, ray: Ray) -> Option; 12 | fn aabb(&self) -> AABB; 13 | } 14 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "tracing" 3 | version = "0.2.0" 4 | authors = ["Yoann Blein "] 5 | 6 | [features] 7 | default = ["gui"] 8 | gui = ["sdl2"] 9 | 10 | [dependencies] 11 | rand = "^0.4" 12 | rayon = "^1" 13 | time = "^0" 14 | image = "^0" 15 | serde = "^1" 16 | serde_derive = "^1" 17 | bincode = "^1" 18 | 19 | sdl2 = { version = "^0", optional = true } 20 | 21 | serde_json = "^1" 22 | 23 | [profile.release] 24 | #lto = true 25 | #debug = true 26 | 27 | [profile.dev] 28 | opt-level = 2 29 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2017 Yoann Blein 2 | 3 | Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. 4 | 5 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 6 | -------------------------------------------------------------------------------- /src/math/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod vec3; 2 | pub mod mat4; 3 | pub mod frame; 4 | pub mod ray; 5 | pub mod aabb; 6 | 7 | pub use vec3::Vec3; 8 | pub use mat4::Mat4; 9 | pub use frame::Frame; 10 | pub use ray::Ray; 11 | pub use aabb::AABB; 12 | pub use std::f32::{INFINITY, NEG_INFINITY}; 13 | pub use std::f32::consts::*; 14 | 15 | pub const EPSILON: f32 = 1e-5; 16 | pub const INV_PI: f32 = FRAC_1_PI; 17 | pub const INV_2_PI: f32 = 0.5 * FRAC_1_PI; 18 | pub const INV_4_PI: f32 = 0.25 * FRAC_1_PI; 19 | 20 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] 21 | pub enum Axis { X, Y, Z } 22 | 23 | pub fn lerp(a: Vec3, b: Vec3, t: f32) -> Vec3 { 24 | (1.0 - t) * a + t * b 25 | } 26 | 27 | pub fn bilerp(x00: Vec3, x01: Vec3, x10: Vec3, x11: Vec3, (u, v): (f32, f32)) -> Vec3 { 28 | lerp(lerp(x00, x01, u), lerp(x10, x11, u), v) 29 | } 30 | -------------------------------------------------------------------------------- /src/math/frame.rs: -------------------------------------------------------------------------------- 1 | use math::Vec3; 2 | 3 | /// Right-handed orthonormal basis -- Y is up 4 | pub struct Frame(Vec3, Vec3, Vec3); 5 | 6 | impl Frame { 7 | pub fn from_up(normal: Vec3) -> Frame { 8 | let tangent = if normal.x.abs() > normal.y.abs() { 9 | Vec3::new(normal.z, 0.0, -normal.x) / (normal.x * normal.x + normal.z * normal.z).sqrt() 10 | } else { 11 | Vec3::new(0.0, -normal.z, normal.y) / (normal.y * normal.y + normal.z * normal.z).sqrt() 12 | }; 13 | let bitangent = Vec3::cross(normal, tangent); 14 | Frame(tangent, normal, bitangent) 15 | } 16 | 17 | #[inline(always)] 18 | pub fn to_world(&self, v: Vec3) -> Vec3 { 19 | self.0 * v.x + self.1 * v.y + self.2 * v.z 20 | } 21 | 22 | #[inline(always)] 23 | pub fn to_local(&self, v: Vec3) -> Vec3 { 24 | Vec3::new(Vec3::dot(v, self.0), Vec3::dot(v, self.1), Vec3::dot(v, self.2)) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /scenes/material-testball/LICENSE.txt: -------------------------------------------------------------------------------- 1 | This is the Tungsten version of 'Material Test Ball' by Benedikt Bitterli, downloaded from https://benedikt-bitterli.me/resources/ 2 | 3 | The original file may be obtained here: https://benedikt-bitterli.me/resources 4 | 5 | This scene was released under a CC0 license and is in the public domain. 6 | It may be copied, modified and used commercially, without permission or 7 | attribution. However, crediting the artist is encouraged. 8 | 9 | For more information about the license, please see 10 | https://creativecommons.org/publicdomain/zero/1.0/ 11 | 12 | 13 | This scene contains an environment map by Bernhard Vogl, available here: 14 | http://dativ.at/lightprobes/ 15 | The environment map is NOT covered by this CC0 license, and is instead 16 | licensed under attribution/non-commercial terms. If you wish to use the 17 | environment map, you must follow the terms of its license. 18 | -------------------------------------------------------------------------------- /src/warp.rs: -------------------------------------------------------------------------------- 1 | use math::*; 2 | 3 | /// Warp a sample from [0:1[² on the unit hemisphere around the Y-axis uniformly 4 | pub fn uniform_hemisphere((u, v): (f32, f32)) -> Vec3 { 5 | let r = (1.0 - u * u).sqrt(); 6 | let phi = 2.0 * PI * v; 7 | let x = r * phi.cos(); 8 | let z = r * phi.sin(); 9 | Vec3::new(x, u, z) 10 | } 11 | 12 | pub fn uniform_hemisphere_pdf(_: Vec3) -> f32 { 13 | INV_2_PI 14 | } 15 | 16 | /// Warp a sample from [0:1[² on the unit hemisphere around the Y-axis with a cosine-weight 17 | pub fn cosine_hemisphere((u, v): (f32, f32)) -> Vec3 { 18 | let (x, z) = uniform_disk((u, v)); 19 | let y = (1.0 - u).sqrt(); 20 | Vec3::new(x, y, z) 21 | } 22 | 23 | pub fn cosine_hemisphere_pdf(v: Vec3) -> f32 { 24 | v.y * INV_PI 25 | } 26 | 27 | /// Warp a sample from [0:1[² on the unit sphere 28 | pub fn uniform_sphere((u, v): (f32, f32)) -> Vec3 { 29 | let y = 1.0 - 2.0 * u; 30 | let r = (1.0 - y * y).sqrt(); 31 | let phi = 2.0 * PI * v; 32 | Vec3::new(r * phi.cos(), y, r * phi.sin()) 33 | } 34 | 35 | pub fn uniform_sphere_pdf(_: Vec3) -> f32 { 36 | INV_4_PI 37 | } 38 | 39 | /// Warp a sample from [0:1[² on the unit disk 40 | pub fn uniform_disk((u, v): (f32, f32)) -> (f32, f32) { 41 | let r = u.sqrt(); 42 | let theta = 2.0 * PI * v; 43 | (r * theta.cos(), r * theta.sin()) 44 | } 45 | 46 | /* 47 | pub fn beckmann(u: f32, v: f32, alpha: f32) -> Vec3 { 48 | let phi = u * 2.0 * PI; 49 | let p = v * phi / (2.0 * PI); 50 | let lg = (1.0-(2.0*PI*p/phi)).log10(); 51 | let denom = (1.0 - (alpha*alpha*lg)).sqrt(); 52 | let theta = (1.0/denom).acos(); 53 | 54 | let phi = 2.0 * PI * v; 55 | let r = theta.sin(); 56 | 57 | let x = r * phi.cos(); 58 | let y = theta.cos(); 59 | let z = r * phi.sin(); 60 | 61 | Vec3::new(x, y, z).normalized() 62 | } 63 | */ 64 | 65 | /// Warp a sample from [0;1[ to a tent over [-1;1[ 66 | pub fn tent1d(u: f32) -> f32 { 67 | let x = 2.0 * u; 68 | if x < 1.0 { 69 | x.sqrt() - 1.0 70 | } else { 71 | 1.0 - (2.0 - x).sqrt() 72 | } 73 | } 74 | 75 | /// Warp a sample from [0;1[² to a tent over [-1;1[² 76 | pub fn tent((u, v): (f32, f32)) -> (f32, f32) { 77 | (tent1d(u), tent1d(v)) 78 | } 79 | -------------------------------------------------------------------------------- /src/camera.rs: -------------------------------------------------------------------------------- 1 | use math::*; 2 | use warp; 3 | 4 | #[derive(Clone)] 5 | pub struct Camera { 6 | pos: Vec3, 7 | transform: Mat4, 8 | 9 | resolution: (usize, usize), 10 | ratio: f32, 11 | pixel_size: (f32, f32), 12 | 13 | fov_rad: f32, 14 | plane_dist: f32, 15 | 16 | aperture_radius: f32, 17 | focus_dist: f32, 18 | 19 | pub tonemap: Tonemap, 20 | } 21 | 22 | impl Camera { 23 | pub fn new(transform: &Mat4, resolution: (usize, usize), fov: f32, tonemap: Tonemap, aperture_radius: Option, focus_dist: Option) -> Camera { 24 | let fov_rad = fov * PI / 180.0; 25 | let plane_dist = 1.0 / (fov_rad * 0.5).tan(); 26 | 27 | Camera { 28 | pos: transform.transform_point(Vec3::zero()), 29 | transform: transform.clone(), 30 | resolution, 31 | ratio: resolution.1 as f32 / resolution.0 as f32, 32 | pixel_size: (1.0 / resolution.0 as f32, 1.0 / resolution.1 as f32), 33 | fov_rad, 34 | plane_dist, 35 | aperture_radius: aperture_radius.unwrap_or(0.0), 36 | focus_dist: focus_dist.unwrap_or(plane_dist), 37 | tonemap, 38 | } 39 | } 40 | 41 | pub fn make_ray(&self, pixel: (usize, usize), img_uv: (f32, f32), lens_uv: (f32, f32)) -> Ray { 42 | let pj = warp::tent(img_uv); 43 | let img_plane_pos = Vec3 { 44 | x: -1.0 + (pixel.0 as f32 + pj.0 + 0.5) * 2.0 * self.pixel_size.0, 45 | y: self.ratio - (pixel.1 as f32 + pj.1 + 0.5) * 2.0 * self.pixel_size.0, 46 | z: self.plane_dist, 47 | }; 48 | let focus_plane_pos = img_plane_pos * (self.focus_dist / img_plane_pos.z); 49 | let lj = warp::uniform_disk(lens_uv); 50 | let lens_pos = Vec3::new(lj.0 * self.aperture_radius, lj.1 * self.aperture_radius, 0.0); 51 | let local_dir = (focus_plane_pos - lens_pos).normalized(); 52 | 53 | Ray { 54 | origin: self.transform.transform_point(lens_pos), 55 | direction: self.transform.transform_vector(local_dir).normalized(), 56 | } 57 | } 58 | 59 | pub fn resolution(&self) -> (usize, usize) { 60 | self.resolution 61 | } 62 | 63 | pub fn set_focus_dist(&mut self, focus_dist: Option) { 64 | self.focus_dist = focus_dist.unwrap_or(self.plane_dist) 65 | } 66 | } 67 | 68 | pub type Tonemap = fn(Vec3) -> Vec3; 69 | 70 | pub fn gamma(c: Vec3) -> Vec3 { 71 | c.map(|v| v.min(1.0).powf(1.0 / 2.2)) 72 | } 73 | 74 | pub fn filmic(c: Vec3) -> Vec3 { 75 | c.map(|v| { 76 | let x = (v - 0.004).max(0.0); 77 | (x*(6.2*x + 0.5)) / (x*(6.2*x + 1.7) + 0.06) 78 | }) 79 | } 80 | -------------------------------------------------------------------------------- /src/math/aabb.rs: -------------------------------------------------------------------------------- 1 | use math::*; 2 | 3 | /// Axis-Aligned Bounding Box 4 | #[derive(Copy, Clone, Debug, Serialize, Deserialize)] 5 | pub struct AABB { 6 | pub min: Vec3, 7 | pub max: Vec3, 8 | } 9 | 10 | impl AABB { 11 | #[inline(always)] 12 | pub fn intersect_fast(&self, ray: Ray, inv_dir: Vec3) -> (f32, f32) { 13 | let t_min = (self.min - ray.origin) * inv_dir; 14 | let t_max = (self.max - ray.origin) * inv_dir; 15 | let t1 = Vec3::min(t_min, t_max); 16 | let t2 = Vec3::max(t_min, t_max); 17 | let t_near = t1.x.max(t1.y).max(t1.z); 18 | let t_far = t2.x.min(t2.y).min(t2.z); 19 | if t_near > t_far { 20 | return (-1.0, -1.0); 21 | } 22 | (t_near, t_far) 23 | //if t_near < 0.0 { t_far } else { t_near } 24 | } 25 | 26 | pub fn intersect(&self, ray: Ray) -> (f32, f32) { 27 | let inv_dir = 1.0 / ray.direction; 28 | self.intersect_fast(ray, inv_dir) 29 | } 30 | 31 | pub fn zero() -> AABB { 32 | AABB { min: Vec3::zero(), max: Vec3::zero() } 33 | } 34 | 35 | pub fn empty() -> AABB { 36 | AABB { min: Vec3::thrice(INFINITY), max: Vec3::thrice(NEG_INFINITY) } 37 | } 38 | 39 | pub fn from_point(p: Vec3) -> AABB { 40 | AABB { min: p, max: p } 41 | } 42 | 43 | pub fn extend_point(&mut self, p: Vec3) { 44 | self.min = Vec3::min(self.min, p); 45 | self.max = Vec3::max(self.max, p); 46 | } 47 | 48 | pub fn union(&self, b: &AABB) -> AABB { 49 | AABB { 50 | min: Vec3::min(self.min, b.min), 51 | max: Vec3::max(self.max, b.max), 52 | } 53 | } 54 | 55 | pub fn longuest_axis(&self) -> Axis { 56 | let dx = self.max.x - self.min.x; 57 | let dy = self.max.y - self.min.y; 58 | let dz = self.max.z - self.min.z; 59 | 60 | if dx > dy { 61 | if dx > dz { Axis::X } else { Axis::Z } 62 | } else { 63 | if dy > dz { Axis::Y } else { Axis::Z } 64 | } 65 | } 66 | 67 | pub fn center(&self) -> Vec3 { 68 | (self.min + self.max) * 0.5 69 | } 70 | 71 | /* 72 | fn normal_at(&self, p: Vec3) -> Vec3 { 73 | if p.x < self.min.x + EPSILON { 74 | Vec3::new(-1.0, 0.0, 0.0) 75 | } else if p.x > self.max.x - EPSILON { 76 | Vec3::new(1.0, 0.0, 0.0) 77 | } else if p.y < self.min.y + EPSILON { 78 | Vec3::new(0.0, -1.0, 0.0) 79 | } else if p.y > self.max.y - EPSILON { 80 | Vec3::new(0.0, 1.0, 0.0) 81 | } else if p.z < self.min.z + EPSILON { 82 | Vec3::new(0.0, 0.0, -1.0) 83 | } else { 84 | Vec3::new(0.0, 0.0, 1.0) 85 | } 86 | } 87 | */ 88 | 89 | pub fn surface_area(&self) -> f32 { 90 | let d = self.max - self.min; 91 | 2.0 * (d.x * d.y + d.x * d.z + d.y * d.z) 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # A simple physically-based path tracer 2 | 3 | This is a physically-based path tracer I wrote from scratch in Rust to better understand how modern renderers work. 4 | Below are some renders it produced. 5 | 6 | ![testball](renders/bathroom.png) 7 | 8 | ![testball](renders/staircase.png) 9 | 10 | ![testball](renders/dragon.png) 11 | 12 | ![testball](renders/testball.png) 13 | 14 | Rendering actually touches many domains (geometry, image reconstruction, spatial data structures, optics, …) and learning all of them was fun, challenging and rewarding. 15 | The codebase is much simpler than feature-rich reference implementations such as [pbrt](https://www.pbrt.org/) or [Mitsuba](http://mitsuba-renderer.org/), but poorly documented. 16 | 17 | ## Features 18 | 19 | - Full physically based global illumination using unbiased unidirectional pathtracing with multiple importance sampling (BSDF and direct light sampling) 20 | - Support meshes composed millions of triangles (the dragon above has more than 800k triangles) loaded from OBJ files and some geometric primitives (sphere, parallelogram, …) 21 | - Area lights (parallelogram and sphere shaped) and Image Based Lighting (see the dragon above) 22 | - Several physically based materials: 23 | - Smooth dielectric (glass), conductor (metal) and plastic with accurate Fresnel effects 24 | - Rough dielectric, conductor and plastic based on the GGX microfacet model described in [Microfacet Models for Refraction through Rough Surfaces](https://diglib.eg.org/handle/10.2312/EGWR.EGSR07.195-206) 25 | - Clearcoat model as described in [Arbitrarily layered micro-facet surfaces](https://dl.acm.org/citation.cfm?doid=1321261.1321292) which produces nice metallic paint effects (see the test ball above) 26 | - Bitmap textures (loaded from common image formats) that can be used to describe material albedo but also roughness (when applicable) 27 | - Two-levels acceleration structure system based on Bounded Volume Hierarchies constructed with the Surface Area Heuristic 28 | - Depth of Field effect 29 | - Fully parallelized rendering 30 | - Progressive rendering with live preview in a SDL window (can be disabled) 31 | 32 | ## Usage 33 | 34 | As this project is not meant for real-use, the interface is not very polished. 35 | There are two ways to describe a scene to render. 36 | 37 | - Describe a scene in Rust with the provided library. 38 | An example is given in `examples/cornell.rs` and can be executed with: 39 | 40 | ``` 41 | cargo run --release --example=cornell 42 | ``` 43 | 44 | - Use the Tungsten file format, although only a *very* limited subset is supported. 45 | An example of scene can be found in `scenes/material-testball` and rendered with: 46 | 47 | ``` 48 | cargo run --release --bin=render_tungsten -- scenes/material-testball/scene.json 49 | ``` 50 | 51 | The current render is saved in `/tmp/image.ppm` when exiting the preview. 52 | 53 | ## TODO 54 | 55 | - Bump mapping 56 | - Adaptive sampling 57 | 58 | ## Credits 59 | 60 | The bathroom, staircase and material test ball scenes are [courtesy of Benedikt Bitterli](https://benedikt-bitterli.me/resources). 61 | 62 | -------------------------------------------------------------------------------- /src/distribution.rs: -------------------------------------------------------------------------------- 1 | use rayon::prelude::*; 2 | 3 | /// Make an importance samplable 1D distribution 4 | /// 5 | /// Will normalize both the `pdf` and the computed `cdf`. 6 | /// Returns the sum of the given PDF. 7 | fn make1d(pdf: &mut [f32], cdf: &mut [f32]) -> f32 { 8 | cdf[0] = pdf[0]; 9 | for i in 1..cdf.len() { 10 | cdf[i] = cdf[i - 1] + pdf[i]; 11 | } 12 | 13 | let total = *cdf.last().unwrap(); 14 | debug_assert!(total.is_finite(), "distribution has non-finite values"); 15 | 16 | if total <= 0.0 { 17 | println!("Warning: the distribution is null and should not be sampled"); 18 | return 0.0; 19 | } 20 | 21 | for v in pdf.iter_mut() { 22 | *v /= total; 23 | } 24 | for v in cdf.iter_mut() { 25 | *v /= total; 26 | } 27 | 28 | return total; 29 | } 30 | 31 | /// Importance sample a 1D distribution 32 | /// 33 | /// Returns the sampled index and its PDF. 34 | fn sample1d(pdf: &[f32], cdf: &[f32], u: f32) -> (usize, f32) { 35 | let i = match cdf.binary_search_by(|v| v.partial_cmp(&u).unwrap()) { 36 | Ok(v) => v, 37 | Err(v) => v, 38 | }; 39 | (i, pdf[i]) 40 | } 41 | 42 | pub struct Distribution1D { 43 | pdf: Vec, 44 | cdf: Vec, 45 | } 46 | 47 | impl Distribution1D { 48 | pub fn new(weights: Vec) -> Distribution1D { 49 | let mut pdf = weights; 50 | let mut cdf = vec![0.0; pdf.len()]; 51 | let _ = make1d(&mut pdf[..], &mut cdf[..]); 52 | Distribution1D { pdf, cdf } 53 | } 54 | 55 | pub fn sample(&self, u: f32) -> (usize, f32) { 56 | sample1d(&self.pdf[..], &self.cdf[..], u) 57 | } 58 | } 59 | 60 | pub struct Distribution2D { 61 | width: usize, 62 | height: usize, 63 | conditional_pdf: Vec, 64 | conditional_cdf: Vec, 65 | marginal_pdf: Vec, 66 | marginal_cdf: Vec, 67 | } 68 | 69 | impl Distribution2D { 70 | pub fn new(weights: Vec, width: usize, height: usize) -> Distribution2D { 71 | debug_assert_eq!(weights.len(), width * height); 72 | 73 | let mut conditional_cdf = vec![0.0; weights.len()]; 74 | let mut conditional_pdf = weights; 75 | let mut marginal_cdf = vec![0.0; height]; 76 | let mut marginal_pdf = { 77 | let chunks_pdf = conditional_pdf.par_chunks_mut(width); 78 | let chunks_cdf = conditional_cdf.par_chunks_mut(width); 79 | chunks_pdf.zip(chunks_cdf).map(|(pdf, cdf)| make1d(pdf, cdf)).collect::>() 80 | }; 81 | let _ = make1d(&mut marginal_pdf[..], &mut marginal_cdf[..]); 82 | 83 | Distribution2D { width, height, conditional_pdf, conditional_cdf, marginal_pdf, marginal_cdf } 84 | } 85 | 86 | pub fn sample(&self, u: f32, v: f32) -> ((usize, usize), f32) { 87 | // first sample the marginal distribution to find a row 88 | let (s1, p1) = sample1d(&self.marginal_pdf[..], &self.marginal_cdf[..], v); 89 | // then sample the distribution of the chosen row `s1` 90 | let i0 = self.width * s1; 91 | let i1 = i0 + self.width; 92 | let (s0, p0) = sample1d(&self.conditional_pdf[i0..i1], &self.conditional_cdf[i0..i1], u); 93 | ((s0, s1), p0 * p1) 94 | } 95 | 96 | pub fn pdf(&self, x: usize, y: usize) -> f32 { 97 | let x = x.min(self.width - 1); 98 | let y = y.min(self.height - 1); 99 | self.conditional_pdf[y * self.width + x] * self.marginal_pdf[y] 100 | } 101 | } 102 | -------------------------------------------------------------------------------- /src/integrator.rs: -------------------------------------------------------------------------------- 1 | use math::*; 2 | use geometry::*; 3 | use scene::*; 4 | use texture::*; 5 | use material::*; 6 | use warp::*; 7 | use light::*; 8 | 9 | use rand::Rng; 10 | 11 | pub fn estimate_radiance(scene: &Scene, ray: Ray, rng: &mut R) -> Vec3 { 12 | let nb_lights = scene.nb_lights(); 13 | let light_pick_prob = 1.0 / nb_lights as f32; 14 | 15 | let mut path_weight = Vec3::thrice(1.0); 16 | let mut radiance = Vec3::zero(); 17 | let mut ray = ray; 18 | let mut specular_bounce = true; 19 | let mut last_pdf_dir = 1.0; 20 | 21 | for nb_bounces in 0.. { 22 | let (intersection, material) = match scene.intersect(ray) { 23 | Some(Hit::Scatterer(its, mat)) => (its, mat), 24 | Some(Hit::Emitter(light, dist)) => { 25 | let contrib = light.eval_direct(ray.direction); 26 | let mis_weight = if !specular_bounce { 27 | let direct_pdf = light.pdf_direct(ray.direction, dist); 28 | mis2(last_pdf_dir, direct_pdf * light_pick_prob) 29 | } else { 30 | 1.0 31 | }; 32 | radiance += path_weight * mis_weight * contrib; 33 | 34 | // lights do not reflect; stop here 35 | break; 36 | } 37 | None => break, 38 | }; 39 | 40 | // compute some geometry at intersection 41 | let normal = intersection.normal; 42 | let hit = ray.point_at(intersection.distance); 43 | let shading_frame = Frame::from_up(normal); 44 | let local_in = shading_frame.to_local(ray.direction); 45 | 46 | let cont_prob = path_weight.max_elem().min(1.0); 47 | 48 | if !material.is_purely_specular() && nb_lights > 0 { 49 | // direct light sampling (also known as "next event estimation") 50 | let light_idx = (nb_lights as f32 * rng.gen::()) as usize; 51 | if let Some(ref light) = scene.get_light(light_idx) { 52 | let (emission, light_sample) = light.sample_direct(hit, rng.gen()); 53 | if !scene.occluded(hit, normal, light_sample.dir, light_sample.dist) { 54 | let local_out = shading_frame.to_local(light_sample.dir); 55 | let bsdf_eval = material.eval(local_in, local_out, intersection.uv); 56 | let bsdf_pdf = material.pdf(local_in, local_out, intersection.uv); 57 | let mis_weight = mis2(light_sample.pdf * light_pick_prob, bsdf_pdf * cont_prob); 58 | radiance += path_weight * emission * bsdf_eval * (mis_weight / (light_sample.pdf * light_pick_prob)); 59 | } 60 | } 61 | } 62 | 63 | let bsdf_sample = material.sample(local_in, intersection.uv, Vec3::new(rng.gen(), rng.gen(), rng.gen())); 64 | 65 | if bsdf_sample.weight == Vec3::zero() { 66 | break; 67 | } 68 | 69 | last_pdf_dir = bsdf_sample.pdf; 70 | 71 | // possibly terminate path 72 | //if nb_bounces >= 3 { 73 | if nb_bounces > 64 { 74 | // we are probably stuck inside a non transmitive object 75 | //eprintln!("Infinite bouncing detected (cont_prob {:?}, path_weight {:?}, bsdf_sample {:?})", cont_prob, path_weight, (bsdf_sample.weight, bsdf_sample.pdf)); 76 | break; 77 | } 78 | // russian roulette 79 | last_pdf_dir *= cont_prob; 80 | if cont_prob < 1.0 { 81 | if rng.gen::() >= cont_prob { 82 | break; 83 | } 84 | path_weight = path_weight / cont_prob; 85 | } 86 | //} 87 | 88 | path_weight *= bsdf_sample.weight; 89 | specular_bounce = bsdf_sample.is_specular; 90 | 91 | // nudge ray origin to avoid self-intersection 92 | ray.direction = shading_frame.to_world(bsdf_sample.direction).normalized(); 93 | let eps = if Vec3::dot(normal, ray.direction) >= 0.0 { EPSILON } else { -EPSILON }; 94 | ray.origin = hit + normal * eps * 2.0; 95 | } 96 | 97 | radiance 98 | } 99 | 100 | fn mis2(sample_pdf: f32, other_pdf: f32) -> f32 { 101 | let power = |x| x*x; 102 | power(sample_pdf) / (power(sample_pdf) + power(other_pdf)) 103 | } 104 | -------------------------------------------------------------------------------- /src/light.rs: -------------------------------------------------------------------------------- 1 | use distribution::Distribution2D; 2 | use math::*; 3 | use texture::*; 4 | use geometry::Surface; 5 | 6 | pub struct DirectSample { 7 | pub dir: Vec3, 8 | pub dist: f32, 9 | pub pdf: f32, 10 | } 11 | 12 | pub trait SampleDirectSurface: Surface { 13 | fn sample_direct(&self, p: Vec3, uv: (f32, f32)) -> DirectSample; 14 | fn pdf_direct(&self, dir: Vec3, dist: f32) -> f32; 15 | } 16 | 17 | pub trait Light { 18 | fn eval_direct(&self, dir: Vec3) -> Vec3; 19 | 20 | fn sample_direct(&self, p: Vec3, uv: (f32, f32)) -> (Vec3, DirectSample); 21 | fn pdf_direct(&self, dir: Vec3, dist: f32) -> f32; 22 | } 23 | 24 | pub struct EnvMap { 25 | img: Image, 26 | dist: Distribution2D, 27 | transform: Mat4, 28 | inv_transform: Mat4, 29 | } 30 | 31 | impl EnvMap { 32 | pub fn from_image(img: Image, transform: &Mat4) -> EnvMap { 33 | // Construct a row-major 2d distribution based on texels luminance. 34 | // It will be used to importance sample texels according to their contribution. 35 | // The sin(theta) factor counteracts the deformation of equi-rectangular mapping. 36 | let mut weights = vec![0f32; img.width * img.height]; 37 | for y in 0..img.height { 38 | // Compute sin(theta) for the current row, accounting for the half-pixel offset 39 | // due to conversion from discrete to continuous coordinates 40 | let sin_theta = ((y as f32 + 0.5) * PI / img.height as f32).sin(); 41 | for x in 0..img.width { 42 | weights[y * img.width + x] = luminance(img.get(x, y)) * sin_theta; 43 | } 44 | } 45 | let dist = Distribution2D::new(weights, img.width, img.height); 46 | 47 | // TODO: only keep rotation from transform 48 | EnvMap { 49 | img, 50 | dist, 51 | transform: transform.clone(), 52 | inv_transform: transform.inverse(), 53 | } 54 | } 55 | 56 | fn direction_to_uv(&self, d: Vec3) -> ((f32, f32), f32) { 57 | let l = self.inv_transform.transform_vector(d); 58 | let u = l.z.atan2(l.x) * INV_2_PI + 0.5; 59 | let v = (-l.y).acos() * INV_PI; 60 | let sin_theta = (1.0 - l.y * l.y).max(EPSILON).sqrt(); 61 | ((u, v), sin_theta) 62 | } 63 | 64 | fn uv_to_direction(&self, (u, v): (f32, f32)) -> (Vec3, f32) { 65 | let phi = (u - 0.5) * 2.0 * PI; 66 | let theta = v * PI; 67 | let (sin_theta, cos_theta) = theta.sin_cos(); 68 | let (sin_phi, cos_phi) = phi.sin_cos(); 69 | let local_dir = Vec3::new(sin_theta * cos_phi, -cos_theta, sin_theta * sin_phi); 70 | let dir = self.transform.transform_vector(local_dir); 71 | (dir, sin_theta) 72 | } 73 | } 74 | 75 | impl Light for EnvMap { 76 | fn eval_direct(&self, dir: Vec3) -> Vec3 { 77 | let (uv, _) = self.direction_to_uv(dir); 78 | self.img.eval(uv) 79 | } 80 | 81 | fn sample_direct(&self, _p: Vec3, (u, v): (f32, f32)) -> (Vec3, DirectSample) { 82 | let ((x, y), tex_pdf) = self.dist.sample(u, v); 83 | 84 | let u = (x as f32 + 0.5) / self.img.width as f32; 85 | let v = 1.0 - (y as f32 + 0.5) / self.img.height as f32; 86 | let (dir, sin_theta) = self.uv_to_direction((u, v)); 87 | 88 | let img_size = (self.img.width * self.img.height) as f32; 89 | let dir_pdf = tex_pdf * img_size / (2.0 * PI * PI * sin_theta); 90 | let emission = self.img.eval((u, v)); 91 | 92 | (emission, DirectSample { dir, dist: INFINITY, pdf: dir_pdf }) 93 | } 94 | 95 | fn pdf_direct(&self, dir: Vec3, _dist: f32) -> f32 { 96 | let ((u, v), sin_theta) = self.direction_to_uv(dir); 97 | let x = (u * self.img.width as f32) as usize; 98 | let y = ((1.0 - v) * self.img.height as f32) as usize; 99 | 100 | let img_size = (self.img.width * self.img.height) as f32; 101 | let tex_pdf = self.dist.pdf(x, y); 102 | 103 | tex_pdf * img_size / (2.0 * PI * PI * sin_theta) 104 | } 105 | } 106 | 107 | pub struct AreaLight { 108 | pub surface: Box, 109 | pub emission: Vec3, 110 | } 111 | 112 | impl Light for AreaLight { 113 | fn eval_direct(&self, _dir: Vec3) -> Vec3 { 114 | self.emission 115 | } 116 | 117 | fn sample_direct(&self, p: Vec3, uv: (f32, f32)) -> (Vec3, DirectSample) { 118 | (self.emission, self.surface.sample_direct(p, uv)) 119 | } 120 | 121 | fn pdf_direct(&self, dir: Vec3, dist: f32) -> f32 { 122 | self.surface.pdf_direct(dir, dist) 123 | } 124 | } 125 | -------------------------------------------------------------------------------- /src/scene.rs: -------------------------------------------------------------------------------- 1 | use geometry::*; 2 | use material::*; 3 | use light::*; 4 | use math::*; 5 | use bvh::BVH; 6 | use std::sync::Arc; 7 | 8 | pub enum Object { 9 | Emitter(AreaLight), 10 | Scatterer { 11 | surface: Box, 12 | material: Arc 13 | }, 14 | } 15 | 16 | impl Object { 17 | fn is_emitter(&self) -> bool { 18 | match self { 19 | Object::Emitter(_) => true, 20 | _ => false, 21 | } 22 | } 23 | } 24 | 25 | impl Surface for Object { 26 | fn intersect(&self, ray: Ray) -> Option { 27 | match *self { 28 | Object::Emitter(ref area_light) => area_light.surface.intersect(ray), 29 | Object::Scatterer { ref surface, .. } => surface.intersect(ray), 30 | } 31 | } 32 | 33 | fn aabb(&self) -> AABB { 34 | match *self { 35 | Object::Emitter(ref area_light) => area_light.surface.aabb(), 36 | Object::Scatterer { ref surface, .. } => surface.aabb(), 37 | } 38 | } 39 | } 40 | 41 | pub(crate) enum Hit<'a> { 42 | Emitter(&'a Light, f32), 43 | Scatterer(Intersection, &'a Material), 44 | } 45 | 46 | pub struct Scene { 47 | objects: Vec