use crate::cameras::Camera;
use crate::math::{Matrix4, Vector2, Vector3};
use super::sampler::concentric_disk;
use super::settings::RaytraceSettings;
#[derive(Debug, Clone, Copy)]
pub struct RtCamera {
inv_view: Matrix4,
inv_proj: Matrix4,
position: Vector3,
right: Vector3,
up: Vector3,
forward: Vector3,
perspective: bool,
aperture: f32,
focus_distance: f32,
}
impl RtCamera {
pub fn new(camera: &dyn Camera, settings: &RaytraceSettings) -> Self {
let view = camera.view_matrix();
let proj = camera.projection_matrix();
let inv_view = view.invert();
let e = &inv_view.elements;
let right = Vector3::new(e[0], e[1], e[2]).normalize();
let up = Vector3::new(e[4], e[5], e[6]).normalize();
let forward = Vector3::new(-e[8], -e[9], -e[10]).normalize();
let perspective = proj.elements[11].abs() > 1e-6;
Self {
inv_view,
inv_proj: proj.invert(),
position: camera.position(),
right,
up,
forward,
perspective,
aperture: settings.aperture.max(0.0),
focus_distance: settings.focus_distance.max(0.0),
}
}
pub fn with_focus_distance(mut self, d: f32) -> Self {
self.focus_distance = d.max(1e-4);
self
}
pub fn focus_distance(&self) -> f32 {
self.focus_distance
}
pub fn is_perspective(&self) -> bool {
self.perspective
}
pub fn forward(&self) -> Vector3 {
self.forward
}
pub fn position(&self) -> Vector3 {
self.position
}
pub fn right(&self) -> Vector3 {
self.right
}
pub fn up(&self) -> Vector3 {
self.up
}
pub fn inv_view_matrix(&self) -> Matrix4 {
self.inv_view
}
pub fn inv_proj_matrix(&self) -> Matrix4 {
self.inv_proj
}
pub fn ray(&self, ndc: Vector2, lens: (f32, f32)) -> (Vector3, Vector3) {
let near = Vector3::new(ndc.x, ndc.y, 0.0)
.apply_matrix4(&self.inv_proj)
.apply_matrix4(&self.inv_view);
let far = Vector3::new(ndc.x, ndc.y, 1.0)
.apply_matrix4(&self.inv_proj)
.apply_matrix4(&self.inv_view);
let (mut origin, mut dir) = if self.perspective {
let o = self.position;
let d = far - o;
if d.length_sq() <= 1e-20 {
(o, self.forward)
} else {
(o, d.normalize())
}
} else {
let d = far - near;
if d.length_sq() <= 1e-20 {
(near, self.forward)
} else {
(near, d.normalize())
}
};
if self.aperture > 0.0 && self.focus_distance > 0.0 {
let cos = dir.dot(self.forward);
if cos.abs() > 1e-6 {
let t = self.focus_distance / cos;
let focal_point = origin + dir * t;
let (lx, ly) = concentric_disk(lens.0, lens.1);
origin =
origin + self.right * (lx * self.aperture) + self.up * (ly * self.aperture);
let d = focal_point - origin;
if d.length_sq() > 1e-20 {
dir = d.normalize();
}
}
}
(origin, dir)
}
pub fn pixel_ray(
&self,
x: u32,
y: u32,
width: u32,
height: u32,
jitter: (f32, f32),
lens: (f32, f32),
) -> (Vector3, Vector3) {
let u = (x as f32 + jitter.0) / width as f32;
let v = (y as f32 + jitter.1) / height as f32;
self.ray(Vector2::new(u * 2.0 - 1.0, 1.0 - v * 2.0), lens)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::cameras::{OrthographicCamera, PerspectiveCamera};
fn perspective() -> PerspectiveCamera {
let mut c = PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0);
c.position = Vector3::new(0.0, 0.0, 5.0);
c.target = Vector3::ZERO;
c
}
#[test]
fn the_centre_ray_looks_down_the_view_axis() {
let cam = perspective();
let rt = RtCamera::new(&cam, &RaytraceSettings::default());
assert!(rt.is_perspective());
let (o, d) = rt.ray(Vector2::new(0.0, 0.0), (0.5, 0.5));
assert!((o - Vector3::new(0.0, 0.0, 5.0)).length() < 1e-5, "{o:?}");
assert!((d - Vector3::new(0.0, 0.0, -1.0)).length() < 1e-4, "{d:?}");
}
#[test]
fn ndc_corners_spread_the_expected_way() {
let cam = perspective();
let rt = RtCamera::new(&cam, &RaytraceSettings::default());
let (_, right) = rt.ray(Vector2::new(1.0, 0.0), (0.5, 0.5));
let (_, up) = rt.ray(Vector2::new(0.0, 1.0), (0.5, 0.5));
assert!(
right.x > 0.0,
"+X in NDC must go +X in world here: {right:?}"
);
assert!(up.y > 0.0, "+Y in NDC must go up: {up:?}");
let angle = up.dot(Vector3::new(0.0, 0.0, -1.0)).acos();
assert!(
(angle - 30f32.to_radians()).abs() < 1e-3,
"{} deg",
angle.to_degrees()
);
}
#[test]
fn pixel_row_zero_is_the_top_of_the_image() {
let cam = perspective();
let rt = RtCamera::new(&cam, &RaytraceSettings::default());
let (_, top) = rt.pixel_ray(50, 0, 100, 100, (0.5, 0.5), (0.5, 0.5));
let (_, bottom) = rt.pixel_ray(50, 99, 100, 100, (0.5, 0.5), (0.5, 0.5));
assert!(
top.y > bottom.y,
"row 0 should look higher: {top:?} vs {bottom:?}"
);
}
#[test]
fn orthographic_rays_are_parallel() {
let mut cam = OrthographicCamera::new(-2.0, 2.0, 2.0, -2.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 5.0);
let rt = RtCamera::new(&cam, &RaytraceSettings::default());
assert!(!rt.is_perspective());
let (o1, d1) = rt.ray(Vector2::new(-0.5, -0.5), (0.5, 0.5));
let (o2, d2) = rt.ray(Vector2::new(0.5, 0.5), (0.5, 0.5));
assert!((d1 - d2).length() < 1e-5, "{d1:?} vs {d2:?}");
assert!(
(o1 - o2).length() > 0.5,
"origins should differ: {o1:?} {o2:?}"
);
assert!((d1 - Vector3::new(0.0, 0.0, -1.0)).length() < 1e-4);
}
#[test]
fn a_pinhole_ignores_the_lens_sample() {
let cam = perspective();
let rt = RtCamera::new(&cam, &RaytraceSettings::default());
let (o1, d1) = rt.ray(Vector2::new(0.2, -0.3), (0.1, 0.9));
let (o2, d2) = rt.ray(Vector2::new(0.2, -0.3), (0.8, 0.2));
assert!((o1 - o2).length() < 1e-6);
assert!((d1 - d2).length() < 1e-6);
}
#[test]
fn depth_of_field_keeps_the_focal_plane_sharp() {
let cam = perspective();
let settings = RaytraceSettings::default().with_depth_of_field(0.3, 5.0);
let rt = RtCamera::new(&cam, &settings);
let ndc = Vector2::new(0.4, -0.2);
let mut reference = None;
for lens in [(0.1, 0.1), (0.9, 0.5), (0.5, 0.95), (0.25, 0.75)] {
let (o, d) = rt.ray(ndc, lens);
let t = 5.0 / d.dot(rt.forward());
let p = o + d * t;
match reference {
None => reference = Some(p),
Some(r) => assert!((p - r).length() < 1e-3, "{p:?} vs {r:?}"),
}
}
let (o1, _) = rt.ray(ndc, (0.05, 0.5));
let (o2, _) = rt.ray(ndc, (0.95, 0.5));
assert!((o1 - o2).length() > 0.1, "the aperture had no effect");
}
}