use crate::math::{Matrix4, Vector3};
#[derive(Debug, Clone, Copy)]
pub struct ShadowSettings {
pub map_size: u32,
pub bias: f32,
pub normal_bias: f32,
pub camera_size: f32,
pub camera_near: f32,
pub camera_far: f32,
pub radius: f32,
pub cascades: u32,
pub cascade_distance: f32,
pub cascade_split: f32,
pub light_size: f32,
pub filter: Option<ShadowType>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ShadowType {
Basic,
#[default]
Pcf,
PcfSoft,
Pcss,
}
impl ShadowType {
pub(crate) fn code(self) -> u32 {
match self {
ShadowType::Basic => 0,
ShadowType::Pcf => 1,
ShadowType::PcfSoft => 2,
ShadowType::Pcss => 3,
}
}
}
impl Default for ShadowSettings {
fn default() -> Self {
Self {
map_size: 4096,
bias: 0.0,
normal_bias: 0.0,
camera_size: 5.0,
camera_near: 0.1,
camera_far: 500.0,
radius: 1.0,
cascades: 1,
cascade_distance: 0.0,
cascade_split: 0.6,
light_size: 0.0,
filter: None,
}
}
}
pub(crate) const SHADOW_TEXEL_BUDGET: u64 = 32 << 20;
pub(crate) fn shadow_layer_size(requested: u32, lights: usize) -> u32 {
let mut size = requested.clamp(256, 8192).next_power_of_two();
while lights > 1 && size > 256 && lights as u64 * (size as u64).pow(2) > SHADOW_TEXEL_BUDGET {
size /= 2;
}
size
}
pub(crate) const MAX_SHADOW_RECORDS: usize = 16;
#[derive(Clone, Copy)]
pub(crate) enum Caster {
Dir {
dir: Vector3,
settings: ShadowSettings,
},
Spot {
pos: Vector3,
dir: Vector3,
angle: f32,
settings: ShadowSettings,
},
Point {
pos: Vector3,
radius: f32,
settings: ShadowSettings,
},
}
impl Caster {
pub(crate) fn settings(&self) -> &ShadowSettings {
match self {
Caster::Dir { settings, .. }
| Caster::Spot { settings, .. }
| Caster::Point { settings, .. } => settings,
}
}
pub(crate) fn layers(&self) -> usize {
match self {
Caster::Dir { settings, .. } => settings.cascades.clamp(1, 4) as usize,
Caster::Spot { .. } => 1,
Caster::Point { .. } => 6,
}
}
}
pub(crate) fn cascade_frusta(
view: &Matrix4,
projection: &Matrix4,
dir: Vector3,
settings: &ShadowSettings,
map_size: u32,
) -> Vec<([f32; 16], f32)> {
let n = settings.cascades.clamp(1, 4) as usize;
let inv_proj = projection.invert();
let (d0, d1) = (
-Vector3::new(0.0, 0.0, 0.0).apply_matrix4(&inv_proj).z,
-Vector3::new(0.0, 0.0, 1.0).apply_matrix4(&inv_proj).z,
);
let (near, far) = (d0.min(d1).max(1e-4), d0.max(d1));
let reach = if settings.cascade_distance > 0.0 {
settings.cascade_distance.min(far)
} else {
far
};
let reach = reach.max(near * 1.01);
let lambda = settings.cascade_split.clamp(0.0, 1.0);
let split = |i: usize| {
let f = i as f32 / n as f32;
let uniform = near + (reach - near) * f;
let log = near * (reach / near).powf(f);
uniform + (log - uniform) * lambda
};
let inv_view = view.invert();
let rays: Vec<(Vector3, Vector3)> = [(-1.0, -1.0), (1.0, -1.0), (-1.0, 1.0), (1.0, 1.0)]
.iter()
.map(|&(x, y)| {
(
Vector3::new(x, y, 0.25).apply_matrix4(&inv_proj),
Vector3::new(x, y, 0.75).apply_matrix4(&inv_proj),
)
})
.collect();
let at_depth = |a: Vector3, b: Vector3, d: f32| {
let dz = b.z - a.z;
let t = if dz.abs() < 1e-12 {
0.0
} else {
(-d - a.z) / dz
};
(a + (b - a) * t).apply_matrix4(&inv_view)
};
let dir = dir.normalize();
let up = if dir.y.abs() > 0.99 {
Vector3::new(1.0, 0.0, 0.0)
} else {
Vector3::UP
};
let light_frame = Matrix4::look_at(Vector3::ZERO, dir, up);
let light_frame_inv = light_frame.invert();
(0..n)
.map(|i| {
let (d0, d1) = (split(i), split(i + 1));
let corners: Vec<Vector3> = rays
.iter()
.flat_map(|&(a, b)| [at_depth(a, b, d0), at_depth(a, b, d1)])
.collect();
let centre = corners.iter().fold(Vector3::ZERO, |acc, &c| acc + c)
* (1.0 / corners.len() as f32);
let radius = corners
.iter()
.map(|&c| (c - centre).length())
.fold(0.0f32, f32::max);
let radius = (radius * 16.0).ceil() / 16.0;
let texel = 2.0 * radius / map_size.max(1) as f32;
let mut c = centre.apply_matrix4(&light_frame);
c.x = (c.x / texel).floor() * texel;
c.y = (c.y / texel).floor() * texel;
let centre = c.apply_matrix4(&light_frame_inv);
let eye = centre - dir * (radius * 10.0);
let view = Matrix4::look_at(eye, centre, up);
let proj = Matrix4::orthographic(-radius, radius, radius, -radius, 0.0, radius * 12.0);
(proj.multiply(&view).elements, d1)
})
.collect()
}
#[cfg(test)]
mod tests {
use super::shadow_layer_size;
#[test]
fn several_lights_share_a_texel_budget() {
assert_eq!(
shadow_layer_size(8192, 1),
8192,
"one light gets what it asks for"
);
assert_eq!(shadow_layer_size(4096, 2), 4096);
assert_eq!(shadow_layer_size(4096, 4), 2048);
assert_eq!(shadow_layer_size(4096, 8), 2048);
assert_eq!(
shadow_layer_size(1000, 1),
1024,
"rounded up to a power of two"
);
assert_eq!(shadow_layer_size(100, 3), 256, "and never below 256");
}
}