use bevy::prelude::*;
use serde::Deserialize;
use crate::stage::manager::{StageId, StageManager};
use crate::stage::transition::StreamingSource;
#[derive(Component, Debug, Clone, Deserialize, Reflect)]
#[reflect(Component)]
pub struct StageSector {
#[serde(default)]
pub source: Option<String>,
#[serde(default = "default_radius")]
pub radius: f32,
#[serde(default = "default_hysteresis")]
pub hysteresis: f32,
}
fn default_radius() -> f32 {
80.0
}
fn default_hysteresis() -> f32 {
1.3
}
impl Default for StageSector {
fn default() -> Self {
Self {
source: None,
radius: default_radius(),
hysteresis: default_hysteresis(),
}
}
}
impl StageSector {
pub fn unload_radius(&self) -> f32 {
self.radius * self.hysteresis.max(1.0)
}
}
#[derive(Component, Debug, Clone, Copy)]
pub struct SectorLoaded {
pub stage: StageId,
}
pub fn should_be_resident(sector: &StageSector, currently_resident: bool, distance: f32) -> bool {
if currently_resident {
distance <= sector.unload_radius()
} else {
distance <= sector.radius
}
}
pub fn stream_external_sectors(
sources: Query<&GlobalTransform, With<StreamingSource>>,
sectors: Query<(Entity, &StageSector, &GlobalTransform, Option<&SectorLoaded>)>,
mut manager: ResMut<StageManager>,
mut commands: Commands,
) {
if sources.is_empty() {
return;
}
for (entity, sector, transform, loaded) in §ors {
let Some(source_path) = §or.source else {
continue;
};
let distance = sources
.iter()
.map(|source| source.translation().distance(transform.translation()))
.fold(f32::MAX, f32::min);
let resident = loaded.is_some_and(|l| manager.is_resident(l.stage));
let wanted = should_be_resident(sector, resident, distance);
match (resident, wanted) {
(false, true) => {
let stage = manager.load_at(source_path.clone(), transform.compute_transform());
commands.entity(entity).insert(SectorLoaded { stage });
}
(true, false) => {
if let Some(loaded) = loaded {
manager.unload(loaded.stage);
}
commands.entity(entity).remove::<SectorLoaded>();
}
_ => {}
}
}
}
pub fn cull_inline_sectors(
sources: Query<&GlobalTransform, With<StreamingSource>>,
mut sectors: Query<(&StageSector, &GlobalTransform, &mut Visibility)>,
) {
if sources.is_empty() {
return;
}
for (sector, transform, mut visibility) in &mut sectors {
if sector.source.is_some() {
continue;
}
let distance = sources
.iter()
.map(|source| source.translation().distance(transform.translation()))
.fold(f32::MAX, f32::min);
let resident = *visibility != Visibility::Hidden;
let wanted = if should_be_resident(sector, resident, distance) {
Visibility::Inherited
} else {
Visibility::Hidden
};
if *visibility != wanted {
*visibility = wanted;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sector() -> StageSector {
StageSector {
source: Some("levels/north.gltf".into()),
radius: 100.0,
hysteresis: 1.3,
}
}
#[test]
fn a_sector_comes_in_at_its_radius() {
assert!(should_be_resident(§or(), false, 99.0));
assert!(!should_be_resident(§or(), false, 101.0));
}
#[test]
fn a_resident_sector_stays_until_well_past_that_radius() {
assert!(should_be_resident(§or(), true, 120.0));
assert!(!should_be_resident(§or(), true, 131.0));
}
#[test]
fn loitering_on_the_boundary_does_not_thrash() {
let sector = sector();
let mut resident = false;
let mut flips = 0;
for step in 0..40 {
let distance = if step % 2 == 0 { 99.0 } else { 101.0 };
let wanted = should_be_resident(§or, resident, distance);
if wanted != resident {
flips += 1;
resident = wanted;
}
}
assert_eq!(
flips, 1,
"the sector should load once and stay, not reload every frame"
);
}
#[test]
fn a_degenerate_hysteresis_still_never_unloads_inside_the_load_radius() {
let sector = StageSector {
hysteresis: 0.5,
..sector()
};
assert!(should_be_resident(§or, true, 100.0));
}
}