Release Notes for v0.8.1

It's 2020 Now

For the last release I forgot to change the copyright notice, that's fixed now:

$ ./target/release/rs_pbrt assets/scenes/cornell_box.pbrt pbrt version 0.8.1 [Detected 28 cores] Copyright (c) 2016-2020 Jan Douglas Bert Walter. Rust code based on C++ code by Matt Pharr, Greg Humphreys, and Wenzel Jakob. ...

Files Changed

36 files changed, 354 insertions(+), 393 deletions(-) ... deleted examples/shapes_sphere_intersect.rs ...

SurfaceInteraction

The biggest change of this release is about the struct SurfaceInteraction .

modified src/core/interaction.rs @@ -274,7 +274,7 @@ pub struct SurfaceInteraction<'a> { pub dvdx: Cell<Float>, pub dudy: Cell<Float>, pub dvdy: Cell<Float>, - pub primitive: Option<&'a Primitive>, + pub primitive: Option<*const Primitive>, pub shading: Shading, pub bsdf: Option<Bsdf>, pub bssrdf: Option<TabulatedBssrdf>,

The change is less about the struct itself (only the optional pointer to a Primitive changed), but rather when the memory for an instance of the struct is allocated and how it is passed to other parts of the code to be either modified or simply used.

modified src/shapes/triangle.rs @@ -148,7 +147,7 @@ impl Triangle { self.mesh.p[self.mesh.vertex_indices[(self.id * 3) as usize + 2] as usize]; bnd3_union_pnt3(&Bounds3f::new(p0, p1), &p2) } - pub fn intersect(&self, ray: &Ray) -> Option<(Rc<SurfaceInteraction>, Float)> { + pub fn intersect(&self, ray: &Ray, t_hit: &mut Float, isect: &mut SurfaceInteraction) -> bool { // get triangle vertices in _p0_, _p1_, and _p2_ let p0: &Point3f = &self.mesh.p[self.mesh.vertex_indices[(self.id * 3) as usize] as usize]; let p1: &Point3f =

In the past the memory was allocated e.g. during a Triangle intersection with a Ray , now we follow more closely the C++ code, where the memory is allocated once e.g. before we ask for an intersection with the Scene and possibly re-used many times instead of re-allocating another SurfaceInteraction struct.

You can see the difference between v0.8.0 and v0.8.1 easily by running heaptrack.

Ambient Occlusion

modified src/integrators/ao.rs @@ -65,9 +64,10 @@ impl AOIntegrator { differential: r.differential, medium: r.medium.clone(), }; - if let Some(mut isect) = scene.intersect(&mut ray) { + let mut isect: SurfaceInteraction = SurfaceInteraction::default(); + if scene.intersect(&mut ray, &mut isect) { let mode: TransportMode = TransportMode::Radiance; - Rc::get_mut(&mut isect).unwrap().compute_scattering_functions(&ray, true, mode); + isect.compute_scattering_functions(&ray, true, mode); // if (!isect.bsdf) { // VLOG(2) << "Skipping intersection due to null bsdf"; // ray = isect.SpawnRay(ray.d);

For Ambient Occlusion you can see the effect between version 0.8.0 (left side) and 0.8.1 (right side) basically on the right column. That column is reduced a lot. The other columns are more or less the same, except that through scaling you see more details on the right side.

For the allocated memory you can see that the lowest part (orange color) was removed on the left side, and more details of everything above it are visible on the right side.

Direct Lighting

modified src/integrators/directlighting.rs @@ -79,12 +78,11 @@ impl DirectLightingIntegrator { // TODO: ProfilePhase p(Prof::SamplerIntegratorLi); let mut l: Spectrum = Spectrum::new(0.0 as Float); // find closest ray intersection or return background radiance - if let Some(mut isect) = scene.intersect(ray) { + let mut isect: SurfaceInteraction = SurfaceInteraction::default(); + if scene.intersect(ray, &mut isect) { // compute scattering functions for surface interaction let mode: TransportMode = TransportMode::Radiance; - Rc::get_mut(&mut isect) - .unwrap() - .compute_scattering_functions(ray, false, mode); + isect.compute_scattering_functions(ray, false, mode); // if (!isect.bsdf) // return Li(isect.SpawnRay(ray.d), scene, sampler, arena, depth); let wo: Vector3f = isect.wo;

For Direct Lighting you can see as well that the new release almost entirely removes the right column.

The graph for the allocated memory shows as well that far less memory is allocated (because it can be re-used).

Whitted Ray Tracing

modified src/integrators/whitted.rs @@ -50,7 +49,8 @@ impl WhittedIntegrator { ) -> Spectrum { let mut l: Spectrum = Spectrum::default(); // find closest ray intersection or return background radiance - if let Some(mut isect) = scene.intersect(ray) { + let mut isect: SurfaceInteraction = SurfaceInteraction::default(); + if scene.intersect(ray, &mut isect) { // compute emitted and reflected light at ray intersection point // initialize common variables for Whitted integrator @@ -59,9 +59,7 @@ impl WhittedIntegrator { // compute scattering functions for surface interaction let mode: TransportMode = TransportMode::Radiance; - Rc::get_mut(&mut isect) - .unwrap() - .compute_scattering_functions(ray, false, mode); + isect.compute_scattering_functions(ray, false, mode); // if (!isect.bsdf) if let Some(ref _bsdf) = isect.bsdf { } else {

For Whitted Ray Tracing the effect is similar to the one we saw for Ambient Occlusion:

Path Tracing

modified src/integrators/path.rs @@ -91,7 +90,8 @@ impl PathIntegrator { // println!("Path tracer bounce {:?}, current L = {:?}, beta = {:?}", // bounces, l, beta); // intersect _ray_ with scene and store intersection in _isect_ - if let Some(mut isect) = scene.intersect(&mut ray) { + let mut isect: SurfaceInteraction = SurfaceInteraction::default(); + if scene.intersect(&mut ray, &mut isect) { // possibly add emitted light at intersection if bounces == 0 || specular_bounce { // add emitted light at path vertex @@ -104,7 +104,7 @@ impl PathIntegrator { } // compute scattering functions and skip over medium boundaries let mode: TransportMode = TransportMode::Radiance; - Rc::get_mut(&mut isect).unwrap().compute_scattering_functions(&ray, true, mode); + isect.compute_scattering_functions(&ray, true, mode); if let Some(ref _bsdf) = isect.bsdf { // we are fine (for below) } else {

Bi-Directional Path Tracing

modified src/integrators/bdpt.rs @@ -1218,11 +1221,10 @@ pub fn random_walk<'a>( // bounces, beta, pdf_fwd, pdf_rev // ); let mut mi_opt: Option<MediumInteraction> = None; - let mut si_opt: Option<Rc<SurfaceInteraction>> = None; // trace a ray and sample the medium, if any let found_intersection: bool; - if let Some(isect) = scene.intersect(&mut ray) { - si_opt = Some(isect); + let mut isect: SurfaceInteraction = SurfaceInteraction::default(); + if scene.intersect(&mut ray, &mut isect) { found_intersection = true; } else { found_intersection = false; @@ -1286,13 +1288,10 @@ pub fn random_walk<'a>( bounces += 1; } break; - } - if let Some(mut isect) = si_opt { + } else { // compute scattering functions for _mode_ and skip over medium // boundaries - Rc::get_mut(&mut isect) - .unwrap() - .compute_scattering_functions(&ray, true, mode); + isect.compute_scattering_functions(&ray, true, mode); let isect_wo: Vector3f = isect.wo; let isect_shading_n: Normal3f = isect.shading.n; if isect.bsdf.is_none() {

Metropolis Light Transport

modified src/integrators/mlt.rs @@ -437,7 +437,9 @@ impl MLTIntegrator { ) * (n_strategies as Float) } pub fn render(&self, scene: &Scene, num_threads: u8) { - let num_cores = if num_threads == 0_u8 { + let mut num_cores: usize; // TMP + // let num_cores = if num_threads == 0_u8 { + let num_cores_init = if num_threads == 0_u8 { // TMP num_cpus::get() } else { num_threads as usize @@ -445,6 +447,7 @@ impl MLTIntegrator { if let Some(light_distr) = compute_light_power_distribution(scene) { println!("Generating bootstrap paths ..."); // generate bootstrap samples and compute normalization constant $b$ + num_cores = 1; // TMP: disable multi-threading let n_bootstrap_samples: u32 = self.n_bootstrap * (self.max_depth + 1); let mut bootstrap_weights: Vec<Float> = vec![0.0 as Float; n_bootstrap_samples as usize]; @@ -477,7 +480,13 @@ impl MLTIntegrator { ))); let mut p_raster: Point2f = Point2f::default(); *weight = integrator - .l(scene, &light_distr, &mut sampler, depth, &mut p_raster) + .l( + scene, + light_distr.clone(), + &mut sampler, + depth, + &mut p_raster, + ) .y(); } }); @@ -499,6 +508,7 @@ impl MLTIntegrator { let bootstrap: Distribution1D = Distribution1D::new(bootstrap_weights); let b: Float = bootstrap.func_int * (self.max_depth + 1) as Float; // run _n_chains_ Markov chains in parallel + num_cores = num_cores_init; // TMP: re-enable multi-threading let film: Arc<Film> = self.get_camera().get_film(); let n_total_mutations: u64 = self.mutations_per_pixel as u64 * film.get_sample_bounds().area() as u64;

For the Metropolis Light Transport algorithm most of the changes were done in the file responsible for Bi-Directional Path Tracing because they both share some functionality. But what's important is that I had to (temporarily) disable multi-threading for a phase where bootstrap samples are generated and a normalization constant is computed. I might be able to activate multi-threading (for this particular phase) again in later releases, but for now it was more important to save some time for almost all algorithms by re-using the struct SurfaceInteraction where possible instead of allocating and dropping the memory all the time.

Unsafe Code

If you look at the change to the struct SurfaceInteraction again:

modified src/core/interaction.rs @@ -274,7 +274,7 @@ pub struct SurfaceInteraction<'a> { pub dvdx: Cell<Float>, pub dudy: Cell<Float>, pub dvdy: Cell<Float>, - pub primitive: Option<&'a Primitive>, + pub primitive: Option<*const Primitive>, pub shading: Shading, pub bsdf: Option<Bsdf>, pub bssrdf: Option<TabulatedBssrdf>,

The new release allocates the memory for the struct SurfaceInteraction when a ray hits a shape, but the pointer to a Primitive will be set later (or better: somewhere else). Therefore we have to use an Option because we can't use a NULL pointer (like in C++).

$ rg -trust "\.primitive = None" src/shapes/triangle.rs 453: isect.primitive = None; ...

So here are some places where that missing information is filled in:

$ rg -trust "\.primitive = Some" ... src/core/primitive.rs 43: isect.primitive = Some(self); ... src/integrators/bdpt.rs 1326: si_eval.primitive = Some(primitive);

As you can read about here:

Recall that we can create raw pointers in safe code, but we can’t dereference raw pointers and read the data being pointed to.

Therefore we need unsafe code to access the Primitive pointed to:

$ rg -trust "primitive = unsafe" src/core/scene.rs 99: let primitive = unsafe { &*primitive_raw }; src/core/interaction.rs 426: let primitive = unsafe { &*primitive_raw }; 516: let primitive = unsafe { &*primitive_raw }; src/core/integrator.rs 543: let primitive = unsafe { &*primitive_raw }; 556: let primitive = unsafe { &*primitive_raw }; src/core/light.rs 214: let primitive = unsafe { &*primitive_raw }; src/integrators/bdpt.rs 472: let primitive = unsafe { &*primitive_raw }; 538: let primitive = unsafe { &*primitive_raw }; 657: let primitive = unsafe { &*primitive_raw }; 746: let primitive = unsafe { &*primitive_raw };

Here is a piece of Rust code how to get access to the Primitive from the SurfaceInteraction and call a member function:

if hit_surface { found_surface_interaction = true ; if let Some(primitive_raw) = light_isect.primitive { let primitive = unsafe { &*primitive_raw }; if let Some(area_light) = primitive. get_area_light () { ... } } }

The End

I hope I didn't forget anything important. Have fun and enjoy the v0.8.1 release.