use crate::content::lighting::DirectionalShadow;
use glam::camera;
use glam::{DVec3, Mat3, Mat4, Vec3, Vec4};
pub(crate) const MAX_SHADOW_CASCADES: usize = 4;
pub(crate) const SHADOW_CASCADE_OVERLAP: f32 = 0.2;
pub(crate) const SHADOW_PANCAKE_SIZE: f32 = 20.;
const SPLIT_SHARES: [f32; MAX_SHADOW_CASCADES - 1] = [0.1, 0.2, 0.5];
const MIN_RANGE: f32 = 0.001;
const MAX_DISTANCE: f32 = 8192.;
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub(crate) struct Cascade {
pub clip_from_world: Mat4,
pub texel_size: f32,
pub far_bound: f32,
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub(crate) struct Cascades {
list: [Cascade; MAX_SHADOW_CASCADES],
count: usize,
}
impl Cascades {
pub fn as_slice(&self) -> &[Cascade] {
&self.list[..self.count]
}
fn from_bounds(bounds: &[f32], mut fit: impl FnMut(usize, f32) -> Cascade) -> Self {
let mut cascades = Self::default();
for (index, &far_bound) in bounds.iter().enumerate() {
cascades.list[index] = fit(index, far_bound);
}
cascades.count = bounds.len();
cascades
}
pub fn camera(
view: Mat4,
projection: Mat4,
direction: Vec3,
shadow: &DirectionalShadow,
map_size: u32,
origin: DVec3,
) -> Self {
let near = camera_near(projection);
let bounds = cascade_bounds(shadow, near);
let world_from_light = world_from_light(direction);
let origin = light_origin(world_from_light, origin);
let light_from_camera = world_from_light.transpose() * view.inverse();
Self::from_bounds(bounds.as_slice(), |index, far_bound| {
let near_bound = if index == 0 {
near
} else {
next_near_bound(bounds.as_slice()[index - 1])
};
let corners = slice_corners(projection, near_bound, far_bound);
calculate_cascade(
corners,
map_size as f32,
world_from_light,
light_from_camera,
far_bound,
origin,
)
})
}
pub fn capture(
center: Vec3,
direction: Vec3,
shadow: &DirectionalShadow,
map_size: u32,
origin: DVec3,
) -> Self {
let bounds = cascade_bounds(shadow, 0.);
let world_from_light = world_from_light(direction);
let origin = light_origin(world_from_light, origin);
let light_from_capture = world_from_light.transpose() * Mat4::from_translation(center);
Self::from_bounds(bounds.as_slice(), |_, far_bound| {
let f = far_bound;
let corners = [
Vec3::new(f, -f, f),
Vec3::new(f, f, f),
Vec3::new(-f, f, f),
Vec3::new(-f, -f, f),
Vec3::new(f, -f, -f),
Vec3::new(f, f, -f),
Vec3::new(-f, f, -f),
Vec3::new(-f, -f, -f),
];
calculate_cascade(
corners,
map_size as f32,
world_from_light,
light_from_capture,
far_bound,
origin,
)
})
}
}
fn light_origin(world_from_light: Mat4, origin: DVec3) -> DVec3 {
Mat3::from_mat4(world_from_light).transpose().as_dmat3() * origin
}
struct Bounds {
list: [f32; MAX_SHADOW_CASCADES],
count: usize,
}
impl Bounds {
fn as_slice(&self) -> &[f32] {
&self.list[..self.count]
}
}
fn cascade_bounds(shadow: &DirectionalShadow, near: f32) -> Bounds {
let distance = if shadow.distance.is_nan() {
0.
} else {
shadow.distance
}
.min(MAX_DISTANCE)
.max(near + MIN_RANGE);
let count = shadow.cascades.clamp(1, MAX_SHADOW_CASCADES as u32) as usize;
let range = distance - near;
let mut list = [distance; MAX_SHADOW_CASCADES];
for (bound, share) in list[..count - 1].iter_mut().zip(SPLIT_SHARES) {
*bound = near + share * range;
}
Bounds { list, count }
}
pub(crate) fn next_near_bound(far_bound: f32) -> f32 {
far_bound - SHADOW_CASCADE_OVERLAP * far_bound.abs()
}
fn camera_near(projection: Mat4) -> f32 {
let near = projection.inverse() * Vec4::new(0., 0., 1., 1.);
-near.z / near.w
}
fn world_from_light(direction: Vec3) -> Mat4 {
let forward = direction.normalize();
let up = if forward.dot(Vec3::Y).abs() > 0.99 {
Vec3::X
} else {
Vec3::Y
};
camera::rh::view::look_to_mat4(Vec3::ZERO, forward, up).transpose()
}
fn slice_corners(projection: Mat4, near: f32, far: f32) -> [Vec3; 8] {
let inverse = projection.inverse();
let at = |depth: f32| {
let clip = projection * Vec4::new(0., 0., -depth, 1.);
let device_depth = clip.z / clip.w;
[(1., -1.), (1., 1.), (-1., 1.), (-1., -1.)].map(|(x, y)| {
let view = inverse * Vec4::new(x, y, device_depth, 1.);
view.truncate() / view.w
})
};
let [a, b, c, d] = at(near);
let [e, f, g, h] = at(far);
[a, b, c, d, e, f, g, h]
}
fn calculate_cascade(
frustum_corners: [Vec3; 8],
cascade_texture_size: f32,
world_from_light: Mat4,
light_from_camera: Mat4,
far_bound: f32,
light_origin: DVec3,
) -> Cascade {
let mut min = Vec3::splat(f32::MAX);
let mut max = Vec3::splat(f32::MIN);
for corner_camera_view in frustum_corners {
let corner_light_view = light_from_camera.transform_point3(corner_camera_view);
min = min.min(corner_light_view);
max = max.max(corner_light_view);
}
let body_diagonal = (frustum_corners[0] - frustum_corners[6]).length_squared();
let far_plane_diagonal = (frustum_corners[4] - frustum_corners[6]).length_squared();
let cascade_diameter = body_diagonal.max(far_plane_diagonal).sqrt().ceil();
let cascade_texel_size = cascade_diameter / cascade_texture_size;
let near_plane = max.z + SHADOW_PANCAKE_SIZE;
let offset = |origin: f64| origin.rem_euclid(f64::from(cascade_texel_size)) as f32;
let snap = |center: f32, offset: f32| {
((center + offset) / cascade_texel_size).floor() * cascade_texel_size - offset
};
let near_plane_center = Vec3::new(
snap(0.5 * (min.x + max.x), offset(light_origin.x)),
snap(0.5 * (min.y + max.y), offset(light_origin.y)),
near_plane,
);
let world_from_light_transpose = world_from_light.transpose();
let cascade_from_world = Mat4::from_cols(
world_from_light_transpose.x_axis,
world_from_light_transpose.y_axis,
world_from_light_transpose.z_axis,
(-near_plane_center).extend(1.0),
);
let r = (near_plane - min.z).recip();
let clip_from_cascade = Mat4::from_cols(
Vec4::new(2.0 / cascade_diameter, 0.0, 0.0, 0.0),
Vec4::new(0.0, 2.0 / cascade_diameter, 0.0, 0.0),
Vec4::new(0.0, 0.0, r, 0.0),
Vec4::new(0.0, 0.0, 1.0, 1.0),
);
Cascade {
clip_from_world: clip_from_cascade * cascade_from_world,
texel_size: cascade_texel_size,
far_bound,
}
}
#[cfg(test)]
mod tests;