pub mod lod;
use bevy::mesh::Mesh3d;
use bevy::platform::collections::HashMap;
use bevy::prelude::*;
pub use lod::{lod_ranges, parse_lod_name, LodConfig};
use crate::stage::manager::StageRoot;
use crate::stage::transition::StreamingSource;
#[derive(Resource, Debug, Clone, Reflect)]
pub struct StageViewConfig {
pub view_distance: f32,
pub auto_lod: bool,
}
impl Default for StageViewConfig {
fn default() -> Self {
Self {
view_distance: 400.0,
auto_lod: true,
}
}
}
#[derive(Component)]
pub struct LodWired;
type LodCandidates<'w, 's> =
Query<'w, 's, (Entity, &'static Name, Option<&'static ChildOf>), (Added<Name>, Without<LodWired>)>;
type LodGroups = HashMap<(Option<Entity>, String), Vec<(usize, Entity)>>;
pub fn wire_lod_groups(
candidates: LodCandidates,
children: Query<&Children>,
meshes: Query<(), With<Mesh3d>>,
config: Res<LodConfig>,
view: Res<StageViewConfig>,
mut commands: Commands,
) {
if !view.auto_lod {
return;
}
let mut groups: LodGroups = HashMap::new();
for (entity, name, parent) in &candidates {
let Some((base, level)) = parse_lod_name(name.as_str()) else {
continue;
};
groups
.entry((parent.map(ChildOf::parent), base.to_string()))
.or_default()
.push((level, entity));
}
for ((_, base), mut members) in groups {
if members.len() < 2 {
continue;
}
members.sort_by_key(|(level, _)| *level);
let ranges = lod_ranges(members.len(), &config);
for ((level, entity), range) in members.iter().zip(ranges) {
let _ = level;
commands.entity(*entity).insert(LodWired);
let mut applied = false;
if let Ok(kids) = children.get(*entity) {
for kid in kids.iter() {
if meshes.get(kid).is_ok() {
commands.entity(kid).insert(range.clone());
applied = true;
}
}
}
if !applied {
commands.entity(*entity).insert(range.clone());
}
}
debug!("bevy_stage: wired LOD group `{base}`");
}
}
pub fn cull_distant_stages(
sources: Query<&GlobalTransform, With<StreamingSource>>,
mut stages: Query<(&StageRoot, &GlobalTransform, &mut Visibility)>,
config: Res<StageViewConfig>,
) {
if sources.is_empty() {
return;
}
for (root, transform, mut visibility) in &mut stages {
if !root.status.is_ready() {
continue;
}
let nearest = sources
.iter()
.map(|source| source.translation().distance(transform.translation()))
.fold(f32::MAX, f32::min);
let wanted = if nearest > config.view_distance {
Visibility::Hidden
} else {
Visibility::Inherited
};
if *visibility != wanted {
*visibility = wanted;
}
}
}