//! Transactional gravity placement using the editor's hydrated Avian world. use std::collections::HashSet; use std::time::Duration; use avian3d::prelude::*; use bevy::prelude::*; use crate::history::set_transform_group_with_history; use crate::operators::{ActiveOperator, OperatorPhase, OperatorStatus}; use crate::state::EditorMode; use crate::ui::selection_ops::{entity_name, is_mutable_level_object}; use crate::viewport::collider_diagnostics::physics_placement_prerequisite_problems; const STEP_HZ: f64 = 120.0; const STEPS_PER_FRAME: usize = 4; const SETTLE_LINEAR_SPEED: f32 = 0.04; const SETTLE_ANGULAR_SPEED: f32 = 0.04; const SETTLE_STEPS: u32 = 30; const MAX_STEPS: u32 = 1_200; #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub enum PhysicsPlacementPhase { #[default] Inactive, Dropping, Settled, TimedOut, } impl PhysicsPlacementPhase { pub fn label(self) -> &'static str { match self { Self::Inactive => "Inactive", Self::Dropping => "Simulating", Self::Settled => "Settled", Self::TimedOut => "Preview stopped", } } } #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub enum PhysicsPlacementRequest { #[default] None, Commit, Cancel, } #[derive(Component, Debug, Clone, Copy, Default)] pub struct PhysicsPlacementPreview; #[derive(Resource, Debug, Default)] pub struct PhysicsPlacementState { pub phase: PhysicsPlacementPhase, pub request: PhysicsPlacementRequest, pub last_error: Option, pub selected_count: usize, pub simulated_steps: u32, session: Option, } impl PhysicsPlacementState { pub fn active(&self) -> bool { self.session.is_some() } pub fn simulated_seconds(&self) -> f32 { self.simulated_steps as f32 / STEP_HZ as f32 } } #[derive(Debug)] struct PlacementSession { selected: Vec, frozen: Vec, stable_steps: u32, } #[derive(Debug, Clone)] struct BodySnapshot { entity: Entity, transform: Transform, position: Option, rotation: Option, rigid_body: RigidBody, linear_velocity: Option, angular_velocity: Option, gravity_scale: Option, sleeping: bool, sleeping_disabled: bool, rigid_body_disabled: bool, } impl BodySnapshot { fn capture(world: &World, entity: Entity) -> Result { Ok(Self { entity, transform: world .get::(entity) .copied() .ok_or_else(|| format!("{} has no Transform", entity_name(world, entity)))?, position: world.get::(entity).copied(), rotation: world.get::(entity).copied(), rigid_body: world.get::(entity).copied().ok_or_else(|| { format!("{} has no hydrated rigid body", entity_name(world, entity)) })?, linear_velocity: world.get::(entity).copied(), angular_velocity: world.get::(entity).copied(), gravity_scale: world.get::(entity).copied(), sleeping: world.get::(entity).is_some(), sleeping_disabled: world.get::(entity).is_some(), rigid_body_disabled: world.get::(entity).is_some(), }) } } pub struct PhysicsPlacementPlugin; impl Plugin for PhysicsPlacementPlugin { fn build(&self, app: &mut App) { app.init_resource::() .add_systems(PostStartup, pause_physics_for_editor) .add_systems(PostUpdate, tick_physics_placement) .add_systems(OnExit(EditorMode::Editing), cancel_physics_placement); } } fn pause_physics_for_editor(mut physics_time: ResMut>) { physics_time.pause(); } pub fn begin_physics_placement( world: &mut World, selected: impl IntoIterator, ) -> Result<(), String> { if *world.resource::>().get() != EditorMode::Editing { return placement_error(world, "Physics placement is available only in Edit mode"); } if world.resource::().active() { return placement_error(world, "A physics placement preview is already active"); } let mut unique = HashSet::new(); let selected = selected .into_iter() .filter(|entity| unique.insert(*entity)) .collect::>(); validate_selection(world, &selected)?; let selected_set = selected.iter().copied().collect::>(); let selected_snapshots = selected .iter() .map(|entity| BodySnapshot::capture(world, *entity)) .collect::, _>>()?; let movable = world .query::<(Entity, &RigidBody)>() .iter(world) .filter_map(|(entity, body)| { (!selected_set.contains(&entity) && *body != RigidBody::Static).then_some(entity) }) .collect::>(); let frozen_snapshots = movable .iter() .map(|entity| BodySnapshot::capture(world, *entity)) .collect::, _>>()?; for snapshot in &frozen_snapshots { if let Ok(mut entity) = world.get_entity_mut(snapshot.entity) { entity.insert(RigidBody::Static); } } for snapshot in &selected_snapshots { let global = world .get::(snapshot.entity) .copied() .unwrap_or_else(|| GlobalTransform::from(snapshot.transform)); if let Ok(mut entity) = world.get_entity_mut(snapshot.entity) { entity.insert(( RigidBody::Dynamic, LinearVelocity::ZERO, AngularVelocity::ZERO, GravityScale(1.0), Position(global.translation()), Rotation(global.rotation()), PhysicsPlacementPreview, )); entity.remove::(); entity.remove::(); } } let selected_count = selected_snapshots.len(); let mut state = world.resource_mut::(); state.phase = PhysicsPlacementPhase::Dropping; state.request = PhysicsPlacementRequest::None; state.last_error = None; state.selected_count = selected_count; state.simulated_steps = 0; state.session = Some(PlacementSession { selected: selected_snapshots, frozen: frozen_snapshots, stable_steps: 0, }); set_operator_status( world, OperatorPhase::Preview, format!("Dropping {selected_count} selected prop(s)"), Vec::new(), ); Ok(()) } pub fn request_physics_placement(world: &mut World, request: PhysicsPlacementRequest) { if world.resource::().active() { world.resource_mut::().request = request; } } pub fn cancel_physics_placement(world: &mut World) { finish_physics_placement(world, false); } pub fn commit_physics_placement(world: &mut World) { finish_physics_placement(world, true); } fn finish_physics_placement(world: &mut World, commit: bool) { let Some(mut state) = world.remove_resource::() else { return; }; let Some(session) = state.session.take() else { world.insert_resource(state); return; }; let final_transforms = session .selected .iter() .filter_map(|snapshot| { world .get::(snapshot.entity) .copied() .map(|transform| (snapshot.entity, transform)) }) .collect::>(); for snapshot in &session.frozen { restore_snapshot(world, snapshot, true); } for snapshot in &session.selected { restore_snapshot(world, snapshot, !commit); if let Ok(mut entity) = world.get_entity_mut(snapshot.entity) { entity.remove::(); } } if commit { let changes = session.selected.iter().filter_map(|snapshot| { final_transforms .iter() .find(|(entity, _)| *entity == snapshot.entity) .map(|(_, new)| (snapshot.entity, snapshot.transform, *new)) }); set_transform_group_with_history(world, changes); } state.phase = PhysicsPlacementPhase::Inactive; state.request = PhysicsPlacementRequest::None; state.selected_count = 0; state.simulated_steps = 0; state.last_error = None; world.insert_resource(state); clear_operator_status(world); } fn tick_physics_placement(world: &mut World) { let escape = world .get_resource::>() .is_some_and(|keys| keys.just_pressed(KeyCode::Escape)); let enter = world .get_resource::>() .is_some_and(|keys| keys.just_pressed(KeyCode::Enter)); let request = world.resource::().request; let settled = matches!( world.resource::().phase, PhysicsPlacementPhase::Settled | PhysicsPlacementPhase::TimedOut ); if escape || request == PhysicsPlacementRequest::Cancel { cancel_physics_placement(world); return; } if request == PhysicsPlacementRequest::Commit || (enter && settled) { commit_physics_placement(world); return; } if world.resource::().phase != PhysicsPlacementPhase::Dropping { return; } for _ in 0..STEPS_PER_FRAME { world .resource_mut::>() .advance_by(Duration::from_secs_f64(1.0 / STEP_HZ)); world.run_schedule(FixedPostUpdate); } let Some(mut state) = world.remove_resource::() else { return; }; state.simulated_steps = state.simulated_steps.saturating_add(STEPS_PER_FRAME as u32); let Some(session) = state.session.as_mut() else { world.insert_resource(state); return; }; let at_rest = session.selected.iter().all(|snapshot| { let linear = world .get::(snapshot.entity) .map_or(0.0, |velocity| velocity.length()); let angular = world .get::(snapshot.entity) .map_or(0.0, |velocity| velocity.length()); (linear <= SETTLE_LINEAR_SPEED && angular <= SETTLE_ANGULAR_SPEED) || world.get::(snapshot.entity).is_some() }); session.stable_steps = if at_rest { session.stable_steps.saturating_add(STEPS_PER_FRAME as u32) } else { 0 }; let mut status = None; if session.stable_steps >= SETTLE_STEPS { state.phase = PhysicsPlacementPhase::Settled; status = Some(( OperatorPhase::Preview, "Placement settled; commit or cancel".to_string(), Vec::new(), )); } else if state.simulated_steps >= MAX_STEPS { state.phase = PhysicsPlacementPhase::TimedOut; status = Some(( OperatorPhase::Preview, "Placement reached its 10 second preview limit".to_string(), vec!["Bodies are still moving; commit the current pose or cancel".to_string()], )); } world.insert_resource(state); if let Some((phase, hint, warnings)) = status { set_operator_status(world, phase, hint, warnings); } } fn validate_selection(world: &mut World, selected: &[Entity]) -> Result<(), String> { if selected.is_empty() { return placement_error(world, "Select at least one prop to place with physics"); } let mut problems = Vec::new(); for entity in selected { let name = entity_name(world, *entity); if !is_mutable_level_object(world, *entity) { problems.push(format!( "{name}: selection is locked, linked, or not a level object" )); continue; } problems.extend(physics_placement_prerequisite_problems(world, *entity)); } if problems.is_empty() { Ok(()) } else { placement_error(world, problems.join("\n")) } } fn restore_snapshot(world: &mut World, snapshot: &BodySnapshot, restore_pose: bool) { let Ok(mut entity) = world.get_entity_mut(snapshot.entity) else { return; }; entity.insert(snapshot.rigid_body); restore_optional(&mut entity, snapshot.linear_velocity); restore_optional(&mut entity, snapshot.angular_velocity); restore_optional(&mut entity, snapshot.gravity_scale); restore_marker::(&mut entity, snapshot.sleeping); restore_marker::(&mut entity, snapshot.sleeping_disabled); restore_marker::(&mut entity, snapshot.rigid_body_disabled); if restore_pose { entity.insert(snapshot.transform); restore_optional(&mut entity, snapshot.position); restore_optional(&mut entity, snapshot.rotation); } } fn restore_optional(entity: &mut EntityWorldMut<'_>, value: Option) { if let Some(value) = value { entity.insert(value); } else { entity.remove::(); } } fn restore_marker(entity: &mut EntityWorldMut<'_>, present: bool) { if present { entity.insert(T::default()); } else { entity.remove::(); } } fn placement_error(world: &mut World, message: impl Into) -> Result { let message = message.into(); world.resource_mut::().last_error = Some(message.clone()); set_operator_status( world, OperatorPhase::Blocked, "Physics placement could not start".to_string(), message.lines().map(str::to_string).collect(), ); Err(message) } fn set_operator_status( world: &mut World, phase: OperatorPhase, hint: String, warnings: Vec, ) { if let Some(mut operator) = world.get_resource_mut::() { operator.status = Some(OperatorStatus { id: "physics.placement".to_string(), label: "Physics Placement".to_string(), phase, hint, warnings, }); } } fn clear_operator_status(world: &mut World) { if let Some(mut operator) = world.get_resource_mut::() { if operator .status .as_ref() .is_some_and(|status| status.id == "physics.placement") { operator.status = None; } } } #[cfg(test)] mod tests { use super::*; use crate::history::{apply_command_undo, EditorHistory}; use bevy::asset::{AssetApp, AssetPlugin}; use bevy::state::app::StatesPlugin; use shared::{ColliderDesc, LevelObject, RigidBodyDesc}; fn app_with_physics() -> App { let mut app = App::new(); app.add_plugins(( MinimalPlugins, AssetPlugin::default(), StatesPlugin, TransformPlugin, PhysicsPlugins::default(), )) .init_asset::() .init_state::() .init_resource::() .init_resource::(); app.finish(); app.cleanup(); app.update(); app.world_mut().resource_mut::>().pause(); app } fn spawn_placeable(world: &mut World, name: &str, transform: Transform) -> Entity { world .spawn(( Name::new(name.to_string()), LevelObject, RigidBodyDesc::default(), ColliderDesc::default(), RigidBody::Static, Collider::cuboid(1.0, 1.0, 1.0), transform, )) .id() } #[test] fn reports_missing_authoring_prerequisites_without_starting() { let mut app = app_with_physics(); let entity = app .world_mut() .spawn((Name::new("No Physics"), LevelObject, Transform::default())) .id(); let error = begin_physics_placement(app.world_mut(), [entity]).unwrap_err(); assert!(error.contains("add and enable a Rigid Body")); assert!(error.contains("add and enable a non-trigger Collider")); assert!(!app.world().resource::().active()); } #[test] fn cancel_restores_selected_and_unrelated_motion_state_exactly() { let mut app = app_with_physics(); let selected = spawn_placeable( app.world_mut(), "Selected", Transform::from_xyz(1.0, 4.0, 2.0), ); app.world_mut().entity_mut(selected).insert(( RigidBody::Kinematic, LinearVelocity(Vec3::new(1.0, 2.0, 3.0)), AngularVelocity(Vec3::new(0.1, 0.2, 0.3)), GravityScale(0.25), SleepingDisabled, )); let unrelated = app .world_mut() .spawn(( RigidBody::Dynamic, Collider::sphere(0.5), LinearVelocity(Vec3::X * 3.0), Transform::from_xyz(8.0, 2.0, 0.0), )) .id(); app.update(); begin_physics_placement(app.world_mut(), [selected]).unwrap(); assert_eq!( app.world().get::(selected), Some(&RigidBody::Dynamic) ); assert_eq!( app.world().get::(unrelated), Some(&RigidBody::Static) ); for _ in 0..10 { tick_physics_placement(app.world_mut()); } assert!( app.world() .get::(selected) .unwrap() .translation .y < 4.0 ); cancel_physics_placement(app.world_mut()); assert_eq!( app.world().get::(selected).unwrap().translation, Vec3::new(1.0, 4.0, 2.0) ); assert_eq!( app.world().get::(selected), Some(&RigidBody::Kinematic) ); assert_eq!( app.world().get::(selected), Some(&LinearVelocity(Vec3::new(1.0, 2.0, 3.0))) ); assert_eq!( app.world().get::(selected), Some(&GravityScale(0.25)) ); assert!(app.world().get::(selected).is_some()); assert_eq!( app.world().get::(unrelated), Some(&RigidBody::Dynamic) ); assert_eq!( app.world().get::(unrelated), Some(&LinearVelocity(Vec3::X * 3.0)) ); assert_eq!(app.world().resource::().undo_depth(), 0); } #[test] fn real_physics_drop_commits_once_and_undo_restores_start_transform() { let mut app = app_with_physics(); app.world_mut().spawn(( RigidBody::Static, Collider::cuboid(20.0, 0.5, 20.0), Transform::from_xyz(0.0, -0.25, 0.0), )); let start = Transform::from_xyz(0.0, 4.0, 0.0); let prop = spawn_placeable(app.world_mut(), "Drop Prop", start); app.update(); begin_physics_placement(app.world_mut(), [prop]).unwrap(); for _ in 0..400 { tick_physics_placement(app.world_mut()); if app.world().resource::().phase == PhysicsPlacementPhase::Settled { break; } } assert_eq!( app.world().resource::().phase, PhysicsPlacementPhase::Settled ); let settled = *app.world().get::(prop).unwrap(); assert!(settled.translation.y < 1.0, "{settled:?}"); commit_physics_placement(app.world_mut()); assert_eq!(app.world().resource::().undo_depth(), 1); assert_eq!( app.world().resource::().status, "Undo: Move Selection" ); assert_eq!(app.world().get::(prop), Some(&RigidBody::Static)); assert_eq!(*app.world().get::(prop).unwrap(), settled); apply_command_undo(app.world_mut()); assert_eq!(*app.world().get::(prop).unwrap(), start); } }