use bevy::platform::collections::HashMap;
use bevy::prelude::*;
use serde::Deserialize;
use super::anchor::AnchorAlignment;
use super::manager::{StageId, StageManager, StageRoot};
pub const DEFAULT_PRELOAD: f32 = 30.0;
fn default_preload() -> f32 {
DEFAULT_PRELOAD
}
#[derive(Component, Debug, Clone, Deserialize, Reflect)]
#[reflect(Component)]
pub struct StagePortal {
pub target: String,
#[serde(default)]
pub anchor: String,
#[serde(default = "default_preload")]
pub preload: f32,
#[serde(default)]
pub alignment: AnchorAlignment,
}
impl Default for StagePortal {
fn default() -> Self {
Self {
target: String::new(),
anchor: String::new(),
preload: DEFAULT_PRELOAD,
alignment: AnchorAlignment::default(),
}
}
}
#[derive(Component, Debug, Clone, Copy)]
pub struct PortalLink {
pub stage: StageId,
}
#[derive(Component, Debug, Default)]
pub struct PortalCrossing {
sides: HashMap<Entity, f32>,
}
#[derive(Component, Debug, Clone)]
pub struct StreamingSource {
pub unload_distance: f32,
}
impl Default for StreamingSource {
fn default() -> Self {
Self {
unload_distance: DEFAULT_PRELOAD * 2.5,
}
}
}
#[derive(EntityEvent, Debug, Clone)]
pub struct StageEntered {
pub entity: Entity,
pub stage: StageId,
pub from: Option<StageId>,
}
#[derive(Component, Debug, Clone)]
pub struct PortalOrigin {
stage: StageId,
path: String,
at: GlobalTransform,
waited: u32,
}
const RETURN_LINK_TIMEOUT_FRAMES: u32 = 1800;
const RETURN_LINK_RADIUS: f32 = 5.0;
pub fn preload_through_portals(
sources: Query<&GlobalTransform, With<StreamingSource>>,
portals: Query<(Entity, &StagePortal, &GlobalTransform), Without<PortalLink>>,
stage_of: Query<&ChildOf>,
roots: Query<&StageRoot>,
mut manager: ResMut<StageManager>,
mut commands: Commands,
) {
for (entity, portal, portal_transform) in &portals {
if portal.target.is_empty() {
continue;
}
let near = sources.iter().any(|source| {
source.translation().distance(portal_transform.translation()) <= portal.preload
});
if !near {
continue;
}
let owner = owning_stage(entity, &stage_of, &roots);
let stage = manager.load_connected(
portal.target.clone(),
portal.anchor.clone(),
*portal_transform,
portal.alignment,
);
let mut portal_entity = commands.entity(entity);
portal_entity.insert(PortalLink { stage });
if let Some((owner_id, owner_path)) = owner {
commands.spawn(PortalOrigin {
stage: owner_id,
path: owner_path,
at: *portal_transform,
waited: 0,
});
}
}
}
pub fn link_return_portals(
mut origins: Query<(Entity, &mut PortalOrigin)>,
portals: Query<(Entity, &StagePortal, &GlobalTransform), Without<PortalLink>>,
stage_of: Query<&ChildOf>,
roots: Query<&StageRoot>,
mut commands: Commands,
) {
for (origin_entity, mut origin) in &mut origins {
let mut linked = false;
for (entity, portal, transform) in &portals {
if portal.target != origin.path {
continue;
}
if transform.translation().distance(origin.at.translation()) > RETURN_LINK_RADIUS {
continue;
}
if owning_stage(entity, &stage_of, &roots).map(|(id, _)| id) == Some(origin.stage) {
continue;
}
commands.entity(entity).insert(PortalLink {
stage: origin.stage,
});
linked = true;
}
origin.waited += 1;
if linked || origin.waited > RETURN_LINK_TIMEOUT_FRAMES {
commands.entity(origin_entity).despawn();
}
}
}
pub fn detect_portal_crossings(
sources: Query<(Entity, &GlobalTransform), With<StreamingSource>>,
mut portals: Query<(
&StagePortal,
&GlobalTransform,
&PortalLink,
&mut PortalCrossing,
)>,
roots: Query<&StageRoot>,
mut manager: ResMut<StageManager>,
mut commands: Commands,
) {
for (portal, transform, link, mut crossing) in &mut portals {
let _ = portal;
for (source, source_transform) in &sources {
let offset = source_transform.translation() - transform.translation();
let side = offset.dot(*transform.forward());
let lateral = (offset - *transform.forward() * side).length();
let previous = crossing.sides.insert(source, side);
let Some(previous) = previous else {
continue;
};
let crossed = previous <= 0.0 && side > 0.0;
if !crossed || lateral > 6.0 {
continue;
}
if manager.active() == Some(link.stage) {
continue;
}
if !manager.is_resident(link.stage) {
continue;
}
let Some(entity) = manager.entity(link.stage) else {
continue;
};
if !roots.get(entity).map(|r| r.status.is_ready()).unwrap_or(false) {
warn!(
"bevy_stage: crossed into a stage that is not ready yet — \
increase the portal's `preload` distance"
);
continue;
}
let from = manager.active();
manager.activate(link.stage);
commands.trigger(StageEntered {
entity,
stage: link.stage,
from,
});
}
}
}
pub fn unload_distant_stages(
sources: Query<(&GlobalTransform, &StreamingSource)>,
stages: Query<(&StageRoot, &GlobalTransform)>,
mut manager: ResMut<StageManager>,
) {
let active = manager.active();
let mut drop = Vec::new();
for (root, transform) in &stages {
if Some(root.id) == active || !root.status.is_ready() {
continue;
}
let far = sources.iter().all(|(source, settings)| {
source.translation().distance(transform.translation()) > settings.unload_distance
});
if far && !sources.is_empty() {
drop.push(root.id);
}
}
for id in drop {
manager.unload(id);
}
}
fn owning_stage(
entity: Entity,
parents: &Query<&ChildOf>,
roots: &Query<&StageRoot>,
) -> Option<(StageId, String)> {
let mut current = entity;
loop {
if let Ok(root) = roots.get(current) {
return Some((root.id, root.path.clone()));
}
current = parents.get(current).ok()?.parent();
}
}
pub fn attach_portal_state(
portals: Query<Entity, (With<StagePortal>, Without<PortalCrossing>)>,
mut commands: Commands,
) {
for entity in &portals {
commands.entity(entity).insert(PortalCrossing::default());
}
}