mirror of
https://github.com/bevyengine/bevy
synced 2024-12-24 12:03:14 +00:00
b4483dbfc8
## Objective Currently, all directional and point lights have their viewing frusta recalculated every frame, even if they have not moved or been disabled/enabled. ## Solution The relevant systems now make use of change detection to only update those lights whose viewing frusta may have changed.
931 lines
34 KiB
Rust
931 lines
34 KiB
Rust
use std::collections::HashSet;
|
||
|
||
use bevy_asset::Assets;
|
||
use bevy_ecs::prelude::*;
|
||
use bevy_math::{Mat4, UVec2, UVec3, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
|
||
use bevy_reflect::Reflect;
|
||
use bevy_render::{
|
||
camera::{Camera, CameraProjection, OrthographicProjection},
|
||
color::Color,
|
||
prelude::Image,
|
||
primitives::{Aabb, CubemapFrusta, Frustum, Sphere},
|
||
view::{ComputedVisibility, RenderLayers, Visibility, VisibleEntities},
|
||
};
|
||
use bevy_transform::components::GlobalTransform;
|
||
use bevy_utils::tracing::warn;
|
||
use bevy_window::Windows;
|
||
|
||
use crate::{
|
||
calculate_cluster_factors, CubeMapFace, CubemapVisibleEntities, ViewClusterBindings,
|
||
CUBE_MAP_FACES, MAX_POINT_LIGHTS, POINT_LIGHT_NEAR_Z,
|
||
};
|
||
|
||
/// A light that emits light in all directions from a central point.
|
||
///
|
||
/// Real-world values for `intensity` (luminous power in lumens) based on the electrical power
|
||
/// consumption of the type of real-world light are:
|
||
///
|
||
/// | Luminous Power (lumen) (i.e. the intensity member) | Incandescent non-halogen (Watts) | Incandescent halogen (Watts) | Compact fluorescent (Watts) | LED (Watts |
|
||
/// |------|-----|----|--------|-------|
|
||
/// | 200 | 25 | | 3-5 | 3 |
|
||
/// | 450 | 40 | 29 | 9-11 | 5-8 |
|
||
/// | 800 | 60 | | 13-15 | 8-12 |
|
||
/// | 1100 | 75 | 53 | 18-20 | 10-16 |
|
||
/// | 1600 | 100 | 72 | 24-28 | 14-17 |
|
||
/// | 2400 | 150 | | 30-52 | 24-30 |
|
||
/// | 3100 | 200 | | 49-75 | 32 |
|
||
/// | 4000 | 300 | | 75-100 | 40.5 |
|
||
///
|
||
/// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lumen_(unit)#Lighting)
|
||
#[derive(Component, Debug, Clone, Copy, Reflect)]
|
||
#[reflect(Component)]
|
||
pub struct PointLight {
|
||
pub color: Color,
|
||
pub intensity: f32,
|
||
pub range: f32,
|
||
pub radius: f32,
|
||
pub shadows_enabled: bool,
|
||
pub shadow_depth_bias: f32,
|
||
/// A bias applied along the direction of the fragment's surface normal. It is scaled to the
|
||
/// shadow map's texel size so that it can be small close to the camera and gets larger further
|
||
/// away.
|
||
pub shadow_normal_bias: f32,
|
||
}
|
||
|
||
impl Default for PointLight {
|
||
fn default() -> Self {
|
||
PointLight {
|
||
color: Color::rgb(1.0, 1.0, 1.0),
|
||
/// Luminous power in lumens
|
||
intensity: 800.0, // Roughly a 60W non-halogen incandescent bulb
|
||
range: 20.0,
|
||
radius: 0.0,
|
||
shadows_enabled: false,
|
||
shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
|
||
shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl PointLight {
|
||
pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.02;
|
||
pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.6;
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub struct PointLightShadowMap {
|
||
pub size: usize,
|
||
}
|
||
|
||
impl Default for PointLightShadowMap {
|
||
fn default() -> Self {
|
||
Self { size: 1024 }
|
||
}
|
||
}
|
||
|
||
/// A Directional light.
|
||
///
|
||
/// Directional lights don't exist in reality but they are a good
|
||
/// approximation for light sources VERY far away, like the sun or
|
||
/// the moon.
|
||
///
|
||
/// Valid values for `illuminance` are:
|
||
///
|
||
/// | Illuminance (lux) | Surfaces illuminated by |
|
||
/// |-------------------|------------------------------------------------|
|
||
/// | 0.0001 | Moonless, overcast night sky (starlight) |
|
||
/// | 0.002 | Moonless clear night sky with airglow |
|
||
/// | 0.05–0.3 | Full moon on a clear night |
|
||
/// | 3.4 | Dark limit of civil twilight under a clear sky |
|
||
/// | 20–50 | Public areas with dark surroundings |
|
||
/// | 50 | Family living room lights |
|
||
/// | 80 | Office building hallway/toilet lighting |
|
||
/// | 100 | Very dark overcast day |
|
||
/// | 150 | Train station platforms |
|
||
/// | 320–500 | Office lighting |
|
||
/// | 400 | Sunrise or sunset on a clear day. |
|
||
/// | 1000 | Overcast day; typical TV studio lighting |
|
||
/// | 10,000–25,000 | Full daylight (not direct sun) |
|
||
/// | 32,000–100,000 | Direct sunlight |
|
||
///
|
||
/// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lux)
|
||
#[derive(Component, Debug, Clone, Reflect)]
|
||
#[reflect(Component)]
|
||
pub struct DirectionalLight {
|
||
pub color: Color,
|
||
/// Illuminance in lux
|
||
pub illuminance: f32,
|
||
pub shadows_enabled: bool,
|
||
pub shadow_projection: OrthographicProjection,
|
||
pub shadow_depth_bias: f32,
|
||
/// A bias applied along the direction of the fragment's surface normal. It is scaled to the
|
||
/// shadow map's texel size so that it is automatically adjusted to the orthographic projection.
|
||
pub shadow_normal_bias: f32,
|
||
}
|
||
|
||
impl Default for DirectionalLight {
|
||
fn default() -> Self {
|
||
let size = 100.0;
|
||
DirectionalLight {
|
||
color: Color::rgb(1.0, 1.0, 1.0),
|
||
illuminance: 100000.0,
|
||
shadows_enabled: false,
|
||
shadow_projection: OrthographicProjection {
|
||
left: -size,
|
||
right: size,
|
||
bottom: -size,
|
||
top: size,
|
||
near: -size,
|
||
far: size,
|
||
..Default::default()
|
||
},
|
||
shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
|
||
shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl DirectionalLight {
|
||
pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.02;
|
||
pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.6;
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub struct DirectionalLightShadowMap {
|
||
pub size: usize,
|
||
}
|
||
|
||
impl Default for DirectionalLightShadowMap {
|
||
fn default() -> Self {
|
||
#[cfg(feature = "webgl")]
|
||
return Self { size: 2048 };
|
||
#[cfg(not(feature = "webgl"))]
|
||
return Self { size: 4096 };
|
||
}
|
||
}
|
||
|
||
/// An ambient light, which lights the entire scene equally.
|
||
#[derive(Debug)]
|
||
pub struct AmbientLight {
|
||
pub color: Color,
|
||
/// A direct scale factor multiplied with `color` before being passed to the shader.
|
||
pub brightness: f32,
|
||
}
|
||
|
||
impl Default for AmbientLight {
|
||
fn default() -> Self {
|
||
Self {
|
||
color: Color::rgb(1.0, 1.0, 1.0),
|
||
brightness: 0.05,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Add this component to make a [`Mesh`](bevy_render::mesh::Mesh) not cast shadows.
|
||
#[derive(Component)]
|
||
pub struct NotShadowCaster;
|
||
/// Add this component to make a [`Mesh`](bevy_render::mesh::Mesh) not receive shadows.
|
||
#[derive(Component)]
|
||
pub struct NotShadowReceiver;
|
||
|
||
#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
|
||
pub enum SimulationLightSystems {
|
||
AddClusters,
|
||
UpdateClusters,
|
||
AssignLightsToClusters,
|
||
UpdateDirectionalLightFrusta,
|
||
UpdatePointLightFrusta,
|
||
CheckLightVisibility,
|
||
}
|
||
|
||
// Clustered-forward rendering notes
|
||
// The main initial reference material used was this rather accessible article:
|
||
// http://www.aortiz.me/2018/12/21/CG.html
|
||
// Some inspiration was taken from “Practical Clustered Shading” which is part 2 of:
|
||
// https://efficientshading.com/2015/01/01/real-time-many-light-management-and-shadows-with-clustered-shading/
|
||
// (Also note that Part 3 of the above shows how we could support the shadow mapping for many lights.)
|
||
// The z-slicing method mentioned in the aortiz article is originally from Tiago Sousa’s Siggraph 2016 talk about Doom 2016:
|
||
// http://advances.realtimerendering.com/s2016/Siggraph2016_idTech6.pdf
|
||
|
||
#[derive(Component, Debug)]
|
||
pub struct Clusters {
|
||
/// Tile size
|
||
pub(crate) tile_size: UVec2,
|
||
/// Number of clusters in x / y / z in the view frustum
|
||
pub(crate) axis_slices: UVec3,
|
||
/// Distance to the far plane of the first depth slice. The first depth slice is special
|
||
/// and explicitly-configured to avoid having unnecessarily many slices close to the camera.
|
||
pub(crate) near: f32,
|
||
aabbs: Vec<Aabb>,
|
||
pub(crate) lights: Vec<VisiblePointLights>,
|
||
}
|
||
|
||
impl Clusters {
|
||
fn new(tile_size: UVec2, screen_size: UVec2, z_slices: u32) -> Self {
|
||
let mut clusters = Self {
|
||
tile_size,
|
||
axis_slices: Default::default(),
|
||
near: 5.0,
|
||
aabbs: Default::default(),
|
||
lights: Default::default(),
|
||
};
|
||
clusters.update(tile_size, screen_size, z_slices);
|
||
clusters
|
||
}
|
||
|
||
fn from_screen_size_and_z_slices(screen_size: UVec2, z_slices: u32) -> Self {
|
||
let aspect_ratio = screen_size.x as f32 / screen_size.y as f32;
|
||
let n_tiles_y =
|
||
((ViewClusterBindings::MAX_OFFSETS as u32 / z_slices) as f32 / aspect_ratio).sqrt();
|
||
// NOTE: Round down the number of tiles in order to avoid overflowing the maximum number of
|
||
// clusters.
|
||
let n_tiles = UVec2::new(
|
||
(aspect_ratio * n_tiles_y).floor() as u32,
|
||
n_tiles_y.floor() as u32,
|
||
);
|
||
Clusters::new((screen_size + UVec2::ONE) / n_tiles, screen_size, Z_SLICES)
|
||
}
|
||
|
||
fn update(&mut self, tile_size: UVec2, screen_size: UVec2, z_slices: u32) {
|
||
self.tile_size = tile_size;
|
||
self.axis_slices = UVec3::new(
|
||
(screen_size.x + 1) / tile_size.x,
|
||
(screen_size.y + 1) / tile_size.y,
|
||
z_slices,
|
||
);
|
||
// NOTE: Maximum 4096 clusters due to uniform buffer size constraints
|
||
assert!(self.axis_slices.x * self.axis_slices.y * self.axis_slices.z <= 4096);
|
||
}
|
||
}
|
||
|
||
fn clip_to_view(inverse_projection: Mat4, clip: Vec4) -> Vec4 {
|
||
let view = inverse_projection * clip;
|
||
view / view.w
|
||
}
|
||
|
||
fn screen_to_view(screen_size: Vec2, inverse_projection: Mat4, screen: Vec2, ndc_z: f32) -> Vec4 {
|
||
let tex_coord = screen / screen_size;
|
||
let clip = Vec4::new(
|
||
tex_coord.x * 2.0 - 1.0,
|
||
(1.0 - tex_coord.y) * 2.0 - 1.0,
|
||
ndc_z,
|
||
1.0,
|
||
);
|
||
clip_to_view(inverse_projection, clip)
|
||
}
|
||
|
||
// Calculate the intersection of a ray from the eye through the view space position to a z plane
|
||
fn line_intersection_to_z_plane(origin: Vec3, p: Vec3, z: f32) -> Vec3 {
|
||
let v = p - origin;
|
||
let t = (z - Vec3::Z.dot(origin)) / Vec3::Z.dot(v);
|
||
origin + t * v
|
||
}
|
||
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn compute_aabb_for_cluster(
|
||
z_near: f32,
|
||
z_far: f32,
|
||
tile_size: Vec2,
|
||
screen_size: Vec2,
|
||
inverse_projection: Mat4,
|
||
is_orthographic: bool,
|
||
cluster_dimensions: UVec3,
|
||
ijk: UVec3,
|
||
) -> Aabb {
|
||
let ijk = ijk.as_vec3();
|
||
|
||
// Calculate the minimum and maximum points in screen space
|
||
let p_min = ijk.xy() * tile_size;
|
||
let p_max = p_min + tile_size;
|
||
|
||
let cluster_min;
|
||
let cluster_max;
|
||
if is_orthographic {
|
||
// Use linear depth slicing for orthographic
|
||
|
||
// Convert to view space at the cluster near and far planes
|
||
// NOTE: 1.0 is the near plane due to using reverse z projections
|
||
let p_min = screen_to_view(
|
||
screen_size,
|
||
inverse_projection,
|
||
p_min,
|
||
1.0 - (ijk.z / cluster_dimensions.z as f32),
|
||
)
|
||
.xyz();
|
||
let p_max = screen_to_view(
|
||
screen_size,
|
||
inverse_projection,
|
||
p_max,
|
||
1.0 - ((ijk.z + 1.0) / cluster_dimensions.z as f32),
|
||
)
|
||
.xyz();
|
||
|
||
cluster_min = p_min.min(p_max);
|
||
cluster_max = p_min.max(p_max);
|
||
} else {
|
||
// Convert to view space at the near plane
|
||
// NOTE: 1.0 is the near plane due to using reverse z projections
|
||
let p_min = screen_to_view(screen_size, inverse_projection, p_min, 1.0);
|
||
let p_max = screen_to_view(screen_size, inverse_projection, p_max, 1.0);
|
||
|
||
let z_far_over_z_near = -z_far / -z_near;
|
||
let cluster_near = if ijk.z == 0.0 {
|
||
0.0
|
||
} else {
|
||
-z_near * z_far_over_z_near.powf((ijk.z - 1.0) / (cluster_dimensions.z - 1) as f32)
|
||
};
|
||
// NOTE: This could be simplified to:
|
||
// cluster_far = cluster_near * z_far_over_z_near;
|
||
let cluster_far =
|
||
-z_near * z_far_over_z_near.powf(ijk.z / (cluster_dimensions.z - 1) as f32);
|
||
|
||
// Calculate the four intersection points of the min and max points with the cluster near and far planes
|
||
let p_min_near = line_intersection_to_z_plane(Vec3::ZERO, p_min.xyz(), cluster_near);
|
||
let p_min_far = line_intersection_to_z_plane(Vec3::ZERO, p_min.xyz(), cluster_far);
|
||
let p_max_near = line_intersection_to_z_plane(Vec3::ZERO, p_max.xyz(), cluster_near);
|
||
let p_max_far = line_intersection_to_z_plane(Vec3::ZERO, p_max.xyz(), cluster_far);
|
||
|
||
cluster_min = p_min_near.min(p_min_far).min(p_max_near.min(p_max_far));
|
||
cluster_max = p_min_near.max(p_min_far).max(p_max_near.max(p_max_far));
|
||
}
|
||
|
||
Aabb::from_min_max(cluster_min, cluster_max)
|
||
}
|
||
|
||
const Z_SLICES: u32 = 24;
|
||
|
||
pub fn add_clusters(
|
||
mut commands: Commands,
|
||
windows: Res<Windows>,
|
||
images: Res<Assets<Image>>,
|
||
cameras: Query<(Entity, &Camera), Without<Clusters>>,
|
||
) {
|
||
for (entity, camera) in cameras.iter() {
|
||
if let Some(size) = camera.target.get_physical_size(&windows, &images) {
|
||
let clusters = Clusters::from_screen_size_and_z_slices(size, Z_SLICES);
|
||
commands.entity(entity).insert(clusters);
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn update_clusters(
|
||
windows: Res<Windows>,
|
||
images: Res<Assets<Image>>,
|
||
mut views: Query<(&Camera, &mut Clusters)>,
|
||
) {
|
||
for (camera, mut clusters) in views.iter_mut() {
|
||
let is_orthographic = camera.projection_matrix.w_axis.w == 1.0;
|
||
let inverse_projection = camera.projection_matrix.inverse();
|
||
if let Some(screen_size_u32) = camera.target.get_physical_size(&windows, &images) {
|
||
// Don't update clusters if screen size is 0.
|
||
if screen_size_u32.x == 0 || screen_size_u32.y == 0 {
|
||
continue;
|
||
}
|
||
*clusters =
|
||
Clusters::from_screen_size_and_z_slices(screen_size_u32, clusters.axis_slices.z);
|
||
let screen_size = screen_size_u32.as_vec2();
|
||
let tile_size_u32 = clusters.tile_size;
|
||
let tile_size = tile_size_u32.as_vec2();
|
||
|
||
// Calculate view space AABBs
|
||
// NOTE: It is important that these are iterated in a specific order
|
||
// so that we can calculate the cluster index in the fragment shader!
|
||
// I (Rob Swain) choose to scan along rows of tiles in x,y, and for each tile then scan
|
||
// along z
|
||
let mut aabbs = Vec::with_capacity(
|
||
(clusters.axis_slices.y * clusters.axis_slices.x * clusters.axis_slices.z) as usize,
|
||
);
|
||
for y in 0..clusters.axis_slices.y {
|
||
for x in 0..clusters.axis_slices.x {
|
||
for z in 0..clusters.axis_slices.z {
|
||
aabbs.push(compute_aabb_for_cluster(
|
||
clusters.near,
|
||
camera.far,
|
||
tile_size,
|
||
screen_size,
|
||
inverse_projection,
|
||
is_orthographic,
|
||
clusters.axis_slices,
|
||
UVec3::new(x, y, z),
|
||
));
|
||
}
|
||
}
|
||
}
|
||
clusters.aabbs = aabbs;
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Component, Debug, Default)]
|
||
pub struct VisiblePointLights {
|
||
pub entities: Vec<Entity>,
|
||
}
|
||
|
||
impl VisiblePointLights {
|
||
pub fn from_light_count(count: usize) -> Self {
|
||
Self {
|
||
entities: Vec::with_capacity(count),
|
||
}
|
||
}
|
||
|
||
pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Entity> {
|
||
self.entities.iter()
|
||
}
|
||
|
||
pub fn len(&self) -> usize {
|
||
self.entities.len()
|
||
}
|
||
|
||
pub fn is_empty(&self) -> bool {
|
||
self.entities.is_empty()
|
||
}
|
||
}
|
||
|
||
fn view_z_to_z_slice(
|
||
cluster_factors: Vec2,
|
||
z_slices: f32,
|
||
view_z: f32,
|
||
is_orthographic: bool,
|
||
) -> u32 {
|
||
if is_orthographic {
|
||
// NOTE: view_z is correct in the orthographic case
|
||
((view_z - cluster_factors.x) * cluster_factors.y).floor() as u32
|
||
} else {
|
||
// NOTE: had to use -view_z to make it positive else log(negative) is nan
|
||
((-view_z).ln() * cluster_factors.x - cluster_factors.y + 1.0).clamp(0.0, z_slices - 1.0)
|
||
as u32
|
||
}
|
||
}
|
||
|
||
fn ndc_position_to_cluster(
|
||
cluster_dimensions: UVec3,
|
||
cluster_factors: Vec2,
|
||
is_orthographic: bool,
|
||
ndc_p: Vec3,
|
||
view_z: f32,
|
||
) -> UVec3 {
|
||
let cluster_dimensions_f32 = cluster_dimensions.as_vec3();
|
||
let frag_coord =
|
||
(ndc_p.xy() * Vec2::new(0.5, -0.5) + Vec2::splat(0.5)).clamp(Vec2::ZERO, Vec2::ONE);
|
||
let xy = (frag_coord * cluster_dimensions_f32.xy()).floor();
|
||
let z_slice = view_z_to_z_slice(
|
||
cluster_factors,
|
||
cluster_dimensions.z as f32,
|
||
view_z,
|
||
is_orthographic,
|
||
);
|
||
xy.as_uvec2()
|
||
.extend(z_slice)
|
||
.clamp(UVec3::ZERO, cluster_dimensions - UVec3::ONE)
|
||
}
|
||
|
||
// Sort point lights with shadows enabled first, then by a stable key so that the index
|
||
// can be used to render at most `MAX_POINT_LIGHT_SHADOW_MAPS` point light shadows and
|
||
// we keep a stable set of lights visible
|
||
pub(crate) fn point_light_order(
|
||
(entity_1, shadows_enabled_1): (&Entity, &bool),
|
||
(entity_2, shadows_enabled_2): (&Entity, &bool),
|
||
) -> std::cmp::Ordering {
|
||
shadows_enabled_1
|
||
.cmp(shadows_enabled_2)
|
||
.reverse()
|
||
.then_with(|| entity_1.cmp(entity_2))
|
||
}
|
||
|
||
#[derive(Clone, Copy)]
|
||
// data required for assigning lights to clusters
|
||
pub(crate) struct PointLightAssignmentData {
|
||
entity: Entity,
|
||
translation: Vec3,
|
||
range: f32,
|
||
shadows_enabled: bool,
|
||
}
|
||
|
||
// NOTE: Run this before update_point_light_frusta!
|
||
pub(crate) fn assign_lights_to_clusters(
|
||
mut commands: Commands,
|
||
mut global_lights: ResMut<VisiblePointLights>,
|
||
mut views: Query<(Entity, &GlobalTransform, &Camera, &Frustum, &mut Clusters)>,
|
||
lights_query: Query<(Entity, &GlobalTransform, &PointLight, &Visibility)>,
|
||
mut lights: Local<Vec<PointLightAssignmentData>>,
|
||
mut max_point_lights_warning_emitted: Local<bool>,
|
||
) {
|
||
// collect just the relevant light query data into a persisted vec to avoid reallocating each frame
|
||
lights.extend(
|
||
lights_query
|
||
.iter()
|
||
.filter(|(.., visibility)| visibility.is_visible)
|
||
.map(
|
||
|(entity, transform, light, _visibility)| PointLightAssignmentData {
|
||
entity,
|
||
translation: transform.translation,
|
||
shadows_enabled: light.shadows_enabled,
|
||
range: light.range,
|
||
},
|
||
),
|
||
);
|
||
|
||
if lights.len() > MAX_POINT_LIGHTS {
|
||
lights.sort_by(|light_1, light_2| {
|
||
point_light_order(
|
||
(&light_1.entity, &light_1.shadows_enabled),
|
||
(&light_2.entity, &light_2.shadows_enabled),
|
||
)
|
||
});
|
||
|
||
// check each light against each view's frustum, keep only those that affect at least one of our views
|
||
let frusta: Vec<_> = views.iter().map(|(_, _, _, frustum, _)| *frustum).collect();
|
||
let mut lights_in_view_count = 0;
|
||
lights.retain(|light| {
|
||
// take one extra light to check if we should emit the warning
|
||
if lights_in_view_count == MAX_POINT_LIGHTS + 1 {
|
||
false
|
||
} else {
|
||
let light_sphere = Sphere {
|
||
center: light.translation,
|
||
radius: light.range,
|
||
};
|
||
|
||
let light_in_view = frusta
|
||
.iter()
|
||
.any(|frustum| frustum.intersects_sphere(&light_sphere));
|
||
|
||
if light_in_view {
|
||
lights_in_view_count += 1;
|
||
}
|
||
|
||
light_in_view
|
||
}
|
||
});
|
||
|
||
if lights.len() > MAX_POINT_LIGHTS && !*max_point_lights_warning_emitted {
|
||
warn!("MAX_POINT_LIGHTS ({}) exceeded", MAX_POINT_LIGHTS);
|
||
*max_point_lights_warning_emitted = true;
|
||
}
|
||
|
||
lights.truncate(MAX_POINT_LIGHTS);
|
||
}
|
||
|
||
let light_count = lights.len();
|
||
let mut global_lights_set = HashSet::with_capacity(light_count);
|
||
for (view_entity, view_transform, camera, frustum, mut clusters) in views.iter_mut() {
|
||
let view_transform = view_transform.compute_matrix();
|
||
let inverse_view_transform = view_transform.inverse();
|
||
let cluster_count = clusters.aabbs.len();
|
||
let is_orthographic = camera.projection_matrix.w_axis.w == 1.0;
|
||
let cluster_factors = calculate_cluster_factors(
|
||
// NOTE: Using the special cluster near value
|
||
clusters.near,
|
||
camera.far,
|
||
clusters.axis_slices.z as f32,
|
||
is_orthographic,
|
||
);
|
||
|
||
let mut clusters_lights =
|
||
vec![VisiblePointLights::from_light_count(light_count); cluster_count];
|
||
let mut visible_lights = Vec::with_capacity(light_count);
|
||
|
||
for light in lights.iter() {
|
||
let light_sphere = Sphere {
|
||
center: light.translation,
|
||
radius: light.range,
|
||
};
|
||
|
||
// Check if the light is within the view frustum
|
||
if !frustum.intersects_sphere(&light_sphere) {
|
||
continue;
|
||
}
|
||
|
||
// NOTE: The light intersects the frustum so it must be visible and part of the global set
|
||
global_lights_set.insert(light.entity);
|
||
visible_lights.push(light.entity);
|
||
|
||
// Calculate an AABB for the light in view space, find the corresponding clusters for the min and max
|
||
// points of the AABB, then iterate over just those clusters for this light
|
||
let light_aabb_view = Aabb {
|
||
center: (inverse_view_transform * light_sphere.center.extend(1.0)).xyz(),
|
||
half_extents: Vec3::splat(light_sphere.radius),
|
||
};
|
||
let (light_aabb_view_min, light_aabb_view_max) =
|
||
(light_aabb_view.min(), light_aabb_view.max());
|
||
// Is there a cheaper way to do this? The problem is that because of perspective
|
||
// the point at max z but min xy may be less xy in screenspace, and similar. As
|
||
// such, projecting the min and max xy at both the closer and further z and taking
|
||
// the min and max of those projected points addresses this.
|
||
let (
|
||
light_aabb_view_xymin_near,
|
||
light_aabb_view_xymin_far,
|
||
light_aabb_view_xymax_near,
|
||
light_aabb_view_xymax_far,
|
||
) = (
|
||
light_aabb_view_min,
|
||
light_aabb_view_min.xy().extend(light_aabb_view_max.z),
|
||
light_aabb_view_max.xy().extend(light_aabb_view_min.z),
|
||
light_aabb_view_max,
|
||
);
|
||
let (
|
||
light_aabb_clip_xymin_near,
|
||
light_aabb_clip_xymin_far,
|
||
light_aabb_clip_xymax_near,
|
||
light_aabb_clip_xymax_far,
|
||
) = (
|
||
camera.projection_matrix * light_aabb_view_xymin_near.extend(1.0),
|
||
camera.projection_matrix * light_aabb_view_xymin_far.extend(1.0),
|
||
camera.projection_matrix * light_aabb_view_xymax_near.extend(1.0),
|
||
camera.projection_matrix * light_aabb_view_xymax_far.extend(1.0),
|
||
);
|
||
let (
|
||
light_aabb_ndc_xymin_near,
|
||
light_aabb_ndc_xymin_far,
|
||
light_aabb_ndc_xymax_near,
|
||
light_aabb_ndc_xymax_far,
|
||
) = (
|
||
light_aabb_clip_xymin_near.xyz() / light_aabb_clip_xymin_near.w,
|
||
light_aabb_clip_xymin_far.xyz() / light_aabb_clip_xymin_far.w,
|
||
light_aabb_clip_xymax_near.xyz() / light_aabb_clip_xymax_near.w,
|
||
light_aabb_clip_xymax_far.xyz() / light_aabb_clip_xymax_far.w,
|
||
);
|
||
let (light_aabb_ndc_min, light_aabb_ndc_max) = (
|
||
light_aabb_ndc_xymin_near
|
||
.min(light_aabb_ndc_xymin_far)
|
||
.min(light_aabb_ndc_xymax_near)
|
||
.min(light_aabb_ndc_xymax_far),
|
||
light_aabb_ndc_xymin_near
|
||
.max(light_aabb_ndc_xymin_far)
|
||
.max(light_aabb_ndc_xymax_near)
|
||
.max(light_aabb_ndc_xymax_far),
|
||
);
|
||
let min_cluster = ndc_position_to_cluster(
|
||
clusters.axis_slices,
|
||
cluster_factors,
|
||
is_orthographic,
|
||
light_aabb_ndc_min,
|
||
light_aabb_view_min.z,
|
||
);
|
||
let max_cluster = ndc_position_to_cluster(
|
||
clusters.axis_slices,
|
||
cluster_factors,
|
||
is_orthographic,
|
||
light_aabb_ndc_max,
|
||
light_aabb_view_max.z,
|
||
);
|
||
let (min_cluster, max_cluster) =
|
||
(min_cluster.min(max_cluster), min_cluster.max(max_cluster));
|
||
for y in min_cluster.y..=max_cluster.y {
|
||
let row_offset = y * clusters.axis_slices.x;
|
||
for x in min_cluster.x..=max_cluster.x {
|
||
let col_offset = (row_offset + x) * clusters.axis_slices.z;
|
||
for z in min_cluster.z..=max_cluster.z {
|
||
// NOTE: cluster_index = (y * dim.x + x) * dim.z + z
|
||
let cluster_index = (col_offset + z) as usize;
|
||
let cluster_aabb = &clusters.aabbs[cluster_index];
|
||
if light_sphere.intersects_obb(cluster_aabb, &view_transform) {
|
||
clusters_lights[cluster_index].entities.push(light.entity);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for cluster_lights in &mut clusters_lights {
|
||
cluster_lights.entities.shrink_to_fit();
|
||
}
|
||
|
||
clusters.lights = clusters_lights;
|
||
visible_lights.shrink_to_fit();
|
||
commands.entity(view_entity).insert(VisiblePointLights {
|
||
entities: visible_lights,
|
||
});
|
||
}
|
||
global_lights.entities = global_lights_set.into_iter().collect();
|
||
lights.clear();
|
||
}
|
||
|
||
pub fn update_directional_light_frusta(
|
||
mut views: Query<
|
||
(
|
||
&GlobalTransform,
|
||
&DirectionalLight,
|
||
&mut Frustum,
|
||
&Visibility,
|
||
),
|
||
Or<(Changed<GlobalTransform>, Changed<DirectionalLight>)>,
|
||
>,
|
||
) {
|
||
for (transform, directional_light, mut frustum, visibility) in views.iter_mut() {
|
||
// The frustum is used for culling meshes to the light for shadow mapping
|
||
// so if shadow mapping is disabled for this light, then the frustum is
|
||
// not needed.
|
||
if !directional_light.shadows_enabled || !visibility.is_visible {
|
||
continue;
|
||
}
|
||
|
||
let view_projection = directional_light.shadow_projection.get_projection_matrix()
|
||
* transform.compute_matrix().inverse();
|
||
*frustum = Frustum::from_view_projection(
|
||
&view_projection,
|
||
&transform.translation,
|
||
&transform.back(),
|
||
directional_light.shadow_projection.far(),
|
||
);
|
||
}
|
||
}
|
||
|
||
// NOTE: Run this after assign_lights_to_clusters!
|
||
pub fn update_point_light_frusta(
|
||
global_lights: Res<VisiblePointLights>,
|
||
mut views: Query<
|
||
(Entity, &GlobalTransform, &PointLight, &mut CubemapFrusta),
|
||
Or<(Changed<GlobalTransform>, Changed<PointLight>)>,
|
||
>,
|
||
) {
|
||
let projection =
|
||
Mat4::perspective_infinite_reverse_rh(std::f32::consts::FRAC_PI_2, 1.0, POINT_LIGHT_NEAR_Z);
|
||
let view_rotations = CUBE_MAP_FACES
|
||
.iter()
|
||
.map(|CubeMapFace { target, up }| GlobalTransform::identity().looking_at(*target, *up))
|
||
.collect::<Vec<_>>();
|
||
|
||
let global_lights_set = global_lights
|
||
.entities
|
||
.iter()
|
||
.copied()
|
||
.collect::<HashSet<_>>();
|
||
for (entity, transform, point_light, mut cubemap_frusta) in views.iter_mut() {
|
||
// The frusta are used for culling meshes to the light for shadow mapping
|
||
// so if shadow mapping is disabled for this light, then the frusta are
|
||
// not needed.
|
||
// Also, if the light is not relevant for any cluster, it will not be in the
|
||
// global lights set and so there is no need to update its frusta.
|
||
if !point_light.shadows_enabled || !global_lights_set.contains(&entity) {
|
||
continue;
|
||
}
|
||
|
||
// ignore scale because we don't want to effectively scale light radius and range
|
||
// by applying those as a view transform to shadow map rendering of objects
|
||
// and ignore rotation because we want the shadow map projections to align with the axes
|
||
let view_translation = GlobalTransform::from_translation(transform.translation);
|
||
let view_backward = transform.back();
|
||
|
||
for (view_rotation, frustum) in view_rotations.iter().zip(cubemap_frusta.iter_mut()) {
|
||
let view = view_translation * *view_rotation;
|
||
let view_projection = projection * view.compute_matrix().inverse();
|
||
|
||
*frustum = Frustum::from_view_projection(
|
||
&view_projection,
|
||
&transform.translation,
|
||
&view_backward,
|
||
point_light.range,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn check_light_mesh_visibility(
|
||
visible_point_lights: Query<&VisiblePointLights>,
|
||
mut point_lights: Query<(
|
||
&PointLight,
|
||
&GlobalTransform,
|
||
&CubemapFrusta,
|
||
&mut CubemapVisibleEntities,
|
||
Option<&RenderLayers>,
|
||
)>,
|
||
mut directional_lights: Query<(
|
||
&DirectionalLight,
|
||
&Frustum,
|
||
&mut VisibleEntities,
|
||
Option<&RenderLayers>,
|
||
&Visibility,
|
||
)>,
|
||
mut visible_entity_query: Query<
|
||
(
|
||
Entity,
|
||
&Visibility,
|
||
&mut ComputedVisibility,
|
||
Option<&RenderLayers>,
|
||
Option<&Aabb>,
|
||
Option<&GlobalTransform>,
|
||
),
|
||
Without<NotShadowCaster>,
|
||
>,
|
||
) {
|
||
// Directonal lights
|
||
for (directional_light, frustum, mut visible_entities, maybe_view_mask, visibility) in
|
||
directional_lights.iter_mut()
|
||
{
|
||
visible_entities.entities.clear();
|
||
|
||
// NOTE: If shadow mapping is disabled for the light then it must have no visible entities
|
||
if !directional_light.shadows_enabled || !visibility.is_visible {
|
||
continue;
|
||
}
|
||
|
||
let view_mask = maybe_view_mask.copied().unwrap_or_default();
|
||
|
||
for (
|
||
entity,
|
||
visibility,
|
||
mut computed_visibility,
|
||
maybe_entity_mask,
|
||
maybe_aabb,
|
||
maybe_transform,
|
||
) in visible_entity_query.iter_mut()
|
||
{
|
||
if !visibility.is_visible {
|
||
continue;
|
||
}
|
||
|
||
let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
|
||
if !view_mask.intersects(&entity_mask) {
|
||
continue;
|
||
}
|
||
|
||
// If we have an aabb and transform, do frustum culling
|
||
if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
|
||
if !frustum.intersects_obb(aabb, &transform.compute_matrix()) {
|
||
continue;
|
||
}
|
||
}
|
||
|
||
computed_visibility.is_visible = true;
|
||
visible_entities.entities.push(entity);
|
||
}
|
||
|
||
// TODO: check for big changes in visible entities len() vs capacity() (ex: 2x) and resize
|
||
// to prevent holding unneeded memory
|
||
}
|
||
|
||
// Point lights
|
||
for visible_lights in visible_point_lights.iter() {
|
||
for light_entity in visible_lights.entities.iter().copied() {
|
||
if let Ok((
|
||
point_light,
|
||
transform,
|
||
cubemap_frusta,
|
||
mut cubemap_visible_entities,
|
||
maybe_view_mask,
|
||
)) = point_lights.get_mut(light_entity)
|
||
{
|
||
for visible_entities in cubemap_visible_entities.iter_mut() {
|
||
visible_entities.entities.clear();
|
||
}
|
||
|
||
// NOTE: If shadow mapping is disabled for the light then it must have no visible entities
|
||
if !point_light.shadows_enabled {
|
||
continue;
|
||
}
|
||
|
||
let view_mask = maybe_view_mask.copied().unwrap_or_default();
|
||
let light_sphere = Sphere {
|
||
center: transform.translation,
|
||
radius: point_light.range,
|
||
};
|
||
|
||
for (
|
||
entity,
|
||
visibility,
|
||
mut computed_visibility,
|
||
maybe_entity_mask,
|
||
maybe_aabb,
|
||
maybe_transform,
|
||
) in visible_entity_query.iter_mut()
|
||
{
|
||
if !visibility.is_visible {
|
||
continue;
|
||
}
|
||
|
||
let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
|
||
if !view_mask.intersects(&entity_mask) {
|
||
continue;
|
||
}
|
||
|
||
// If we have an aabb and transform, do frustum culling
|
||
if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
|
||
let model_to_world = transform.compute_matrix();
|
||
// Do a cheap sphere vs obb test to prune out most meshes outside the sphere of the light
|
||
if !light_sphere.intersects_obb(aabb, &model_to_world) {
|
||
continue;
|
||
}
|
||
for (frustum, visible_entities) in cubemap_frusta
|
||
.iter()
|
||
.zip(cubemap_visible_entities.iter_mut())
|
||
{
|
||
if frustum.intersects_obb(aabb, &model_to_world) {
|
||
computed_visibility.is_visible = true;
|
||
visible_entities.entities.push(entity);
|
||
}
|
||
}
|
||
} else {
|
||
computed_visibility.is_visible = true;
|
||
for visible_entities in cubemap_visible_entities.iter_mut() {
|
||
visible_entities.entities.push(entity);
|
||
}
|
||
}
|
||
}
|
||
|
||
// TODO: check for big changes in visible entities len() vs capacity() (ex: 2x) and resize
|
||
// to prevent holding unneeded memory
|
||
}
|
||
}
|
||
}
|
||
}
|