Add raytracer runtime benchmark

Adapted from https://github.com/jorendorff/rust-raytrace. Slightly modified for edition 2021 and made deterministic by removing randomness.

Author: Kobzol

collector/runtime-benchmarks/raytracer/Cargo.lock

@@ -0,0 +1,11 @@
+[package]
+name = "raytrace"
+version = "0.1.0"
+authors = ["Jason Orendorff <jason.orendorff@gmail.com>"]
+edition = "2021"
+
+[dependencies]
+lodepng = "0.10"
+benchlib = { path = "../../benchlib" }
+
+[workspace]

collector/runtime-benchmarks/raytracer/Cargo.toml

@@ -0,0 +1,51 @@
+use crate::vec::{random_in_unit_disc, Ray, Vec3};
+
+use std::f32::consts::PI;
+
+#[derive(Clone, Copy, Debug)]
+pub struct Camera {
+    origin: Vec3,
+    u: Vec3, // unit vector in direction of x coordinates
+    v: Vec3, // unit vector in dirction of y coordinates
+    lower_left_corner: Vec3,
+    horizontal: Vec3,
+    vertical: Vec3,
+    lens_radius: f32,
+}
+
+impl Camera {
+    pub fn new(
+        lookfrom: Vec3,
+        lookat: Vec3,
+        vup: Vec3,
+        vfov_degrees: f32,
+        aspect: f32,
+        aperture: f32,
+        focus_distance: f32,
+    ) -> Camera {
+        let theta = vfov_degrees * PI / 180.0;
+        let half_height = (theta / 2.0).tan();
+        let half_width = aspect * half_height;
+        let w = (lookfrom - lookat).to_unit_vector();
+        let u = vup.cross(w).to_unit_vector();
+        let v = w.cross(u);
+        Camera {
+            origin: lookfrom,
+            u,
+            v,
+            lower_left_corner: lookfrom - focus_distance * (half_width * u + half_height * v + w),
+            horizontal: focus_distance * 2.0 * half_width * u,
+            vertical: focus_distance * 2.0 * half_height * v,
+            lens_radius: aperture / 2.0,
+        }
+    }
+
+    pub fn get_ray(&self, u: f32, v: f32) -> Ray {
+        let Vec3(du, dv, _) = self.lens_radius * random_in_unit_disc();
+        let origin = self.origin + du * self.u + dv * self.v;
+        Ray::new(
+            origin,
+            self.lower_left_corner + u * self.horizontal + v * self.vertical - origin,
+        )
+    }
+}

collector/runtime-benchmarks/raytracer/src/camera.rs

@@ -0,0 +1,103 @@
+use benchlib::benchmark::run_benchmark_group;
+use camera::Camera;
+use materials::{Dielectric, Lambertian, Material, Metal};
+use model::{Model, Sphere};
+use std::rc::Rc;
+use vec::{random_in_unit_disc, Vec3};
+
+mod camera; // translate 2D pixel coordinates to 3D rays
+mod materials; // reflective properties of surfaces
+mod model; // geometry of objects in the scene
+mod render;
+mod vec; // basic 3D vector math // the core ray-tracing algorithm
+
+/// Generate a Model containing a bunch of randomly placed spheres.
+fn create_scene() -> Box<dyn Model> {
+    let mut spheres: Vec<Sphere> = vec![
+        Sphere {
+            center: Vec3(0.0, 0.0, -1000.0),
+            radius: 1000.0,
+            material: Box::new(Lambertian {
+                albedo: Vec3(1.0, 0.6, 0.5),
+            }),
+        },
+        Sphere {
+            center: Vec3(-4.0, 0.0, 2.0),
+            radius: 2.0,
+            material: Box::new(Lambertian {
+                albedo: Vec3(0.6, 0.2, 0.2),
+            }),
+        },
+        Sphere {
+            center: Vec3(0.0, 0.0, 2.0),
+            radius: 2.0,
+            material: Box::new(Dielectric { index: 1.5 }),
+        },
+        Sphere {
+            center: Vec3(4.0, 0.0, 2.0),
+            radius: 2.0,
+            material: Box::new(Metal {
+                albedo: Vec3(0.85, 0.9, 0.7),
+                fuzz: 0.0,
+            }),
+        },
+    ];
+
+    fn random_material() -> Box<dyn Material> {
+        Box::new(Lambertian {
+            albedo: Vec3(0.5, 0.5, 0.5),
+        })
+    }
+
+    for _ in 0..500 {
+        let r = 0.4;
+        let Vec3(x, y, _) = random_in_unit_disc();
+        let pos = 20.0 * Vec3(x, y, 0.0) + Vec3(0.0, 0.0, r);
+        if spheres
+            .iter()
+            .all(|s| (s.center - pos).length() >= s.radius + r)
+        {
+            spheres.push(Sphere {
+                center: pos,
+                radius: r,
+                material: random_material(),
+            });
+        }
+    }
+
+    let world: Vec<Box<dyn Model>> = spheres
+        .into_iter()
+        .map(|s| Box::new(s) as Box<dyn Model>)
+        .collect();
+    Box::new(world)
+}
+
+fn main() {
+    const WIDTH: usize = 400;
+    const HEIGHT: usize = 200;
+
+    const NSAMPLES: usize = 100;
+
+    run_benchmark_group(|group| {
+        // Performs raytracing on a simple scene.
+        // Adapted from https://github.com/jorendorff/rust-raytrace.
+        group.register_benchmark("raytracer", || {
+            let scene = create_scene();
+            let lookfrom = Vec3(20.0 * 0.47f32.cos(), 20.0 * 0.47f32.sin(), 3.0);
+            let lookat = Vec3(0.0, 0.0, 1.0);
+            let vup = Vec3(0.0, 0.0, 1.0);
+            let focus_distance = (lookfrom - lookat).length();
+            let aperture = 0.3;
+            let camera = Rc::new(Camera::new(
+                lookfrom,
+                lookat,
+                vup,
+                20.0,
+                WIDTH as f32 / HEIGHT as f32,
+                aperture,
+                focus_distance,
+            ));
+            move || render::render(&*scene, &camera, WIDTH, HEIGHT, NSAMPLES)
+        });
+    });
+}

collector/runtime-benchmarks/raytracer/src/main.rs

@@ -0,0 +1,95 @@
+use crate::model::Hit;
+use crate::vec::{random_in_unit_sphere, Ray, Vec3};
+
+#[derive(Clone, Copy, Debug)]
+pub struct Scatter {
+    pub color: Vec3,
+    pub ray: Option<Ray>,
+}
+
+pub trait Material {
+    fn scatter(&self, r_in: &Ray, rec: &Hit) -> Scatter;
+}
+
+pub struct Lambertian {
+    pub albedo: Vec3,
+}
+
+impl Material for Lambertian {
+    fn scatter(&self, _r_in: &Ray, hit: &Hit) -> Scatter {
+        let target = hit.p + hit.normal + random_in_unit_sphere();
+        Scatter {
+            color: self.albedo,
+            ray: Some(Ray::new(hit.p, target - hit.p)),
+        }
+    }
+}
+
+fn reflect(v: Vec3, n: Vec3) -> Vec3 {
+    v - 2.0 * v.dot(n) * n
+}
+
+pub struct Metal {
+    pub albedo: Vec3,
+    pub fuzz: f32,
+}
+
+impl Material for Metal {
+    fn scatter(&self, r_in: &Ray, hit: &Hit) -> Scatter {
+        let reflected = reflect(r_in.direction, hit.normal);
+        let scattered = Ray::new(hit.p, reflected + self.fuzz * random_in_unit_sphere());
+
+        Scatter {
+            color: self.albedo,
+            ray: if scattered.direction.dot(hit.normal) <= 0.0 {
+                None
+            } else {
+                Some(scattered)
+            },
+        }
+    }
+}
+
+pub struct Dielectric {
+    // Technically, this is not the index of refaction but the ratio of the
+    // index of refraction inside the material to the index of refraction
+    // outside.  But if the material outside is air, its index of refraction is
+    // 1 and so it amounts to the same thing.
+    pub index: f32,
+}
+
+fn refract(v: Vec3, n: Vec3, ni_over_nt: f32) -> Option<Vec3> {
+    let uv = v.to_unit_vector();
+
+    let dt = uv.dot(n);
+    let discriminant = 1.0 - ni_over_nt * ni_over_nt * (1.0 - dt * dt);
+    if discriminant > 0.0 {
+        Some(ni_over_nt * (uv - dt * n) - discriminant.sqrt() * n)
+    } else {
+        None
+    }
+}
+
+const WHITE: Vec3 = Vec3(1.0, 1.0, 1.0);
+
+impl Material for Dielectric {
+    fn scatter(&self, r_in: &Ray, hit: &Hit) -> Scatter {
+        let outward_normal: Vec3;
+        let ni_over_nt: f32;
+
+        if r_in.direction.dot(hit.normal) > 0.0 {
+            outward_normal = -hit.normal;
+            ni_over_nt = self.index;
+        } else {
+            outward_normal = hit.normal;
+            ni_over_nt = 1.0 / self.index;
+        }
+
+        let _ = refract(r_in.direction, outward_normal, ni_over_nt);
+
+        Scatter {
+            color: WHITE,
+            ray: Some(Ray::new(hit.p, reflect(r_in.direction, hit.normal))),
+        }
+    }
+}

collector/runtime-benchmarks/raytracer/src/materials.rs

@@ -0,0 +1,80 @@
+use crate::materials::Material;
+use crate::vec::{Ray, Vec3};
+
+#[derive(Clone, Copy)]
+pub struct Hit<'obj> {
+    pub t: f32,
+    pub p: Vec3,
+    pub normal: Vec3,
+    pub material: &'obj dyn Material,
+}
+
+pub trait Model {
+    fn hit(&self, r: &Ray) -> Option<Hit>;
+}
+
+pub struct Sphere {
+    pub center: Vec3,
+    pub radius: f32,
+    pub material: Box<dyn Material>,
+}
+
+/// Minimum distance a ray must travel before we'll consider a possible hit.
+///
+/// If we try to use 0 here, we get a really strange bug. When a ray hits an object
+/// and bounces, we'll sometimes register another hit on the same sphere,
+/// at some tiny but positive distance, due to floating-point error.
+///
+const T_MIN: f32 = 0.0001;
+
+impl Model for Sphere {
+    fn hit<'a>(&'a self, r: &Ray) -> Option<Hit<'a>> {
+        let oc = r.origin - self.center;
+        let a = r.direction.dot(r.direction);
+        let hb = oc.dot(r.direction);
+        let c = oc.dot(oc) - self.radius * self.radius;
+        let discriminant = hb * hb - a * c;
+        if discriminant > 0.0 {
+            let t = (-hb - discriminant.sqrt()) / a;
+            if t >= T_MIN {
+                let p = r.point_at_parameter(t);
+                return Some(Hit {
+                    t: t,
+                    p: p,
+                    normal: (p - self.center) / self.radius,
+                    material: &*self.material,
+                });
+            }
+            let t = (-hb + discriminant.sqrt()) / a;
+            if t >= T_MIN {
+                let p = r.point_at_parameter(t);
+                return Some(Hit {
+                    t: t,
+                    p: p,
+                    normal: (p - self.center) / self.radius,
+                    material: &*self.material,
+                });
+            }
+        }
+        None
+    }
+}
+
+impl Model for Vec<Box<dyn Model>> {
+    fn hit(&self, r: &Ray) -> Option<Hit> {
+        let mut best = None;
+        for child in self {
+            if let Some(hit) = child.hit(r) {
+                match best {
+                    None => best = Some(hit),
+                    Some(prev) => {
+                        if hit.t < prev.t {
+                            best = Some(hit)
+                        }
+                    }
+                }
+            }
+        }
+        best
+    }
+}