feature: spectral rendering

Cargo.toml

@@ -1,7 +1,8 @@
 [workspace]
 resolver = "2"
 
-members = [
-  "clovers",
-  "clovers-cli",
-]
+members = ["clovers", "clovers-cli"]
+
+[profile.release]
+codegen-units = 1
+lto = "fat"

README.md

@@ -31,3 +31,15 @@ This repository has some example model files for demonstrating triangle-based ob
 - Stanford Bunny model `bunny.stl` CC Attribution 3.0 Unported [Wikipedia](https://commons.wikimedia.org/wiki/File:Stanford_Bunny.stl)
 - Stanford Dragon model `dragon.stl` (stl converted version) CC Attribution [Thingiverse](https://www.thingiverse.com/thing:27666)
 - Rubber Duck model `duck.stl` CC0 1.0 Universal Public Domain [Thingiverse](https://www.thingiverse.com/thing:139894)
+- Triangular Prism model `prism.stl` Public Domain [Wikipedia](https://commons.wikimedia.org/wiki/File:Triangular_prism.stl)
+
+## Useful references
+
+Making this renderer would not have been possible without the availability of an abundance of great literature. Here are listed some of the sources that have been useful:
+
+- [Ray Tracing in One Weekend](https://raytracing.github.io/books/RayTracingInOneWeekend.html)
+- [Ray Tracing: The Next Week](https://raytracing.github.io/books/RayTracingTheNextWeek.html)
+- [Ray Tracing: The Rest of Your Life](https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html)
+- [Physically Meaningful Rendering using Tristimulus Colours](https://doi.org/10.1111/cgf.12676)
+- [Hero Wavelength Spectral Sampling](https://doi.org/10.1111/cgf.12419)
+- [How to interpret the sRGB color space](https://color.org/chardata/rgb/sRGB.pdf)

clovers-cli/Cargo.toml

@@ -10,16 +10,27 @@ path = "src/main.rs"
 
 [dependencies]
 # Internal
-clovers = { path = "../clovers", features = ["serde-derive", "stl", "traces", "gl_tf"], default-features = false }
+clovers = { path = "../clovers", features = [
+  "serde-derive",
+  "stl",
+  "traces",
+  "gl_tf",
+], default-features = false }
 
 # External
 clap = { version = "4.4.1", features = ["std", "derive"] }
 human_format = "1.0.3"
 humantime = "2.1.0"
-image = { version =  "0.24.7", features = ["png"], default-features = false }
+image = { version = "0.24.7", features = ["png"], default-features = false }
 img-parts = "0.3.0"
-indicatif = { version = "0.17.6", features = ["rayon"], default-features = false }
-rand = { version = "0.8.5", features = ["small_rng", "getrandom"], default-features = false }
+indicatif = { version = "0.17.6", features = [
+  "rayon",
+], default-features = false }
+palette = { version = "0.7.3", features = ["serializing"] }
+rand = { version = "0.8.5", features = [
+  "small_rng",
+  "getrandom",
+], default-features = false }
 rayon = "1.7.0"
 serde = { version = "1.0.188", features = ["derive"], default-features = false }
 serde_json = { version = "1.0", features = ["alloc"], default-features = false }

clovers-cli/src/draw_cpu.rs

@@ -1,14 +1,18 @@
-use crate::{color::Color, colorize::colorize, normals::normal_map, ray::Ray, scenes, Float};
+use crate::{colorize::colorize, normals::normal_map, ray::Ray, scenes, Float};
 use clovers::RenderOpts;
 use indicatif::{ProgressBar, ProgressDrawTarget, ProgressStyle};
+use palette::chromatic_adaptation::AdaptInto;
+use palette::convert::IntoColorUnclamped;
+use palette::white_point::E;
+use palette::{IntoColor, LinSrgb, Srgb, Xyz};
 use rand::rngs::SmallRng;
 use rand::{Rng, SeedableRng};
 use rayon::prelude::*;
 use scenes::Scene;
 use std::time::Duration;
 
-/// The main drawing function, returns a `Vec<Color>` as a pixelbuffer.
-pub fn draw(opts: RenderOpts, scene: &Scene) -> Vec<Color> {
+/// The main drawing function, returns a `Vec<Srgb>` as a pixelbuffer.
+pub fn draw(opts: RenderOpts, scene: &Scene) -> Vec<Srgb<u8>> {
     // Progress bar
     let pixels = (opts.width * opts.height) as u64;
     let bar = ProgressBar::new(pixels);
@@ -22,7 +26,7 @@ pub fn draw(opts: RenderOpts, scene: &Scene) -> Vec<Color> {
         bar.enable_steady_tick(Duration::from_millis(100));
     }
 
-    let black = Color::new(0.0, 0.0, 0.0);
+    let black: Srgb<u8> = Srgb::new(0, 0, 0);
     let mut pixelbuffer = vec![black; pixels as usize];
 
     pixelbuffer
@@ -40,15 +44,16 @@ pub fn draw(opts: RenderOpts, scene: &Scene) -> Vec<Color> {
             let mut rng = SmallRng::from_entropy();
 
             // Initialize a mutable base color for the pixel
-            let mut color: Color = Color::new(0.0, 0.0, 0.0);
+            let mut color: LinSrgb = LinSrgb::new(0.0, 0.0, 0.0);
 
             if opts.normalmap {
                 // If we are rendering just a normalmap, make it quick and early return
                 let u = x / width;
                 let v = y / height;
                 let ray: Ray = scene.camera.get_ray(u, v, &mut rng);
                 color = normal_map(&ray, scene, &mut rng);
-                *pixel = color;
+                let color: Srgb = color.into_color();
+                *pixel = color.into_format();
                 return;
             }
             // Otherwise, do a regular render
@@ -60,10 +65,9 @@ pub fn draw(opts: RenderOpts, scene: &Scene) -> Vec<Color> {
                 }
             }
             color /= opts.samples as Float;
-
-            // After multisampling, perform gamma correction and store final color into the pixel
-            color = color.gamma_correction(opts.gamma);
-            *pixel = color;
+            // Gamma / component transfer function
+            let color: Srgb = color.into_color();
+            *pixel = color.into_format();
 
             bar.inc(1);
         });
@@ -80,13 +84,14 @@ fn sample(
     height: Float,
     rng: &mut SmallRng,
     max_depth: u32,
-) -> Option<Color> {
+) -> Option<LinSrgb> {
     let u = (x + rng.gen::<Float>()) / width;
     let v = (y + rng.gen::<Float>()) / height;
     let ray: Ray = scene.camera.get_ray(u, v, rng);
-    let new_color = colorize(&ray, scene, 0, max_depth, rng);
-    // skip NaN and Infinity
-    if new_color.r.is_finite() && new_color.g.is_finite() && new_color.b.is_finite() {
+    let new_color: Xyz<E> = colorize(&ray, scene, 0, max_depth, rng);
+    let new_color: Xyz = new_color.adapt_into();
+    let new_color: LinSrgb = new_color.into_color_unclamped();
+    if new_color.red.is_finite() && new_color.green.is_finite() && new_color.blue.is_finite() {
         return Some(new_color);
     }
     None

clovers-cli/src/main.rs

@@ -45,9 +45,6 @@ struct Opts {
     /// Maximum evaluated bounce depth for each ray
     #[clap(short = 'd', long, default_value = "100")]
     max_depth: u32,
-    /// Gamma correction value
-    #[clap(short, long, default_value = "2.0")]
-    gamma: Float,
     /// Suppress most of the text output
     #[clap(short, long)]
     quiet: bool,
@@ -96,7 +93,6 @@ fn main() -> Result<(), Box<dyn Error>> {
         height: opts.height,
         samples: opts.samples,
         max_depth: opts.max_depth,
-        gamma: opts.gamma,
         quiet: opts.quiet,
         normalmap: opts.normalmap,
     };
@@ -127,7 +123,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let mut img: RgbImage = ImageBuffer::new(width, height);
     img.enumerate_pixels_mut().for_each(|(x, y, pixel)| {
         let index = y * width + x;
-        *pixel = Rgb(pixelbuffer[index as usize].to_rgb_u8());
+        *pixel = Rgb(pixelbuffer[index as usize].into());
     });
 
     // Graphics assume origin at bottom left corner of the screen

clovers/Cargo.toml

@@ -21,9 +21,12 @@ traces = ["tracing"]
 enum_dispatch = "0.3.12"
 gltf = { version = "1.3.0", optional = true }
 nalgebra = { version = "0.32.3", features = ["libm"], default-features = false }
+palette = { version = "0.7.3", features = ["serializing"] }
 rand = { version = "0.8.5", features = ["small_rng"], default-features = false }
 rand_distr = "0.4.3"
-serde = { version = "1.0.188", features = ["derive"], default-features = false, optional = true }
+serde = { version = "1.0.188", features = [
+  "derive",
+], default-features = false, optional = true }
 stl_io = { version = "0.7.0", optional = true }
 tracing = { version = "0.1.37", optional = true }
 

clovers/benches/random.rs

@@ -8,7 +8,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
     let mut rng = SmallRng::from_entropy();
 
     c.bench_function("random in unit sphere", |b| {
-        b.iter(|| random_in_unit_sphere(black_box(&mut rng)))
+        b.iter(|| random_unit_vector(black_box(&mut rng)))
     });
 
     c.bench_function("random in unit disk", |b| {
@@ -25,7 +25,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
 
     let normal = Vec3::new(1.0, 0.0, 0.0);
     c.bench_function("random in hemisphere", |b| {
-        b.iter(|| random_in_hemisphere(normal, black_box(&mut rng)))
+        b.iter(|| random_on_hemisphere(normal, black_box(&mut rng)))
     });
 }
 

clovers/src/bvhnode.rs

@@ -8,6 +8,7 @@ use crate::{
     aabb::AABB,
     hitable::{Empty, HitRecord, Hitable, HitableTrait},
     ray::Ray,
+    wavelength::Wavelength,
     Box, Float, Vec, Vec3,
 };
 
@@ -184,13 +185,20 @@ impl<'scene> HitableTrait for BVHNode<'scene> {
 
     /// Returns a probability density function value based on the children
     #[must_use]
-    fn pdf_value(&self, origin: Vec3, vector: Vec3, time: f32, rng: &mut SmallRng) -> f32 {
+    fn pdf_value(
+        &self,
+        origin: Vec3,
+        vector: Vec3,
+        wavelength: Wavelength,
+        time: Float,
+        rng: &mut SmallRng,
+    ) -> Float {
         match (&*self.left, &*self.right) {
-            (_, Hitable::Empty(_)) => self.left.pdf_value(origin, vector, time, rng),
-            (Hitable::Empty(_), _) => self.right.pdf_value(origin, vector, time, rng),
+            (_, Hitable::Empty(_)) => self.left.pdf_value(origin, vector, wavelength, time, rng),
+            (Hitable::Empty(_), _) => self.right.pdf_value(origin, vector, wavelength, time, rng),
             (_, _) => {
-                (self.left.pdf_value(origin, vector, time, rng)
-                    + self.right.pdf_value(origin, vector, time, rng))
+                (self.left.pdf_value(origin, vector, wavelength, time, rng)
+                    + self.right.pdf_value(origin, vector, wavelength, time, rng))
                     / 2.0
             }
         }

clovers/src/camera.rs

@@ -2,6 +2,7 @@
 
 #![allow(clippy::too_many_arguments)] // TODO: Camera::new() has a lot of arguments.
 
+use crate::wavelength::random_wavelength;
 use crate::{random::random_in_unit_disk, ray::Ray, Float, Vec3, PI};
 use rand::rngs::SmallRng;
 use rand::Rng;
@@ -106,10 +107,15 @@ impl Camera {
         let offset: Vec3 = self.u * rd.x + self.v * rd.y;
         // Randomized time used for motion blur
         let time: Float = rng.gen_range(self.time_0..self.time_1);
-        Ray::new(
-            self.origin + offset,
-            self.lower_left_corner + s * self.horizontal + t * self.vertical - self.origin - offset,
+        // Random wavelength for spectral rendering
+        let wavelength = random_wavelength(rng);
+        Ray {
+            origin: self.origin + offset,
+            direction: self.lower_left_corner + s * self.horizontal + t * self.vertical
+                - self.origin
+                - offset,
             time,
-        )
+            wavelength,
+        }
     }
 }