Files
Blacksite/crates/editor/src/viewport/physics_placement.rs
T
Rbanh 0ce43fc399
CI / Format, lint, test, build (push) Waiting to run
Add collider authoring diagnostics
2026-07-12 22:48:00 -04:00

628 lines
20 KiB
Rust

//! 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<String>,
pub selected_count: usize,
pub simulated_steps: u32,
session: Option<PlacementSession>,
}
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<BodySnapshot>,
frozen: Vec<BodySnapshot>,
stable_steps: u32,
}
#[derive(Debug, Clone)]
struct BodySnapshot {
entity: Entity,
transform: Transform,
position: Option<Position>,
rotation: Option<Rotation>,
rigid_body: RigidBody,
linear_velocity: Option<LinearVelocity>,
angular_velocity: Option<AngularVelocity>,
gravity_scale: Option<GravityScale>,
sleeping: bool,
sleeping_disabled: bool,
rigid_body_disabled: bool,
}
impl BodySnapshot {
fn capture(world: &World, entity: Entity) -> Result<Self, String> {
Ok(Self {
entity,
transform: world
.get::<Transform>(entity)
.copied()
.ok_or_else(|| format!("{} has no Transform", entity_name(world, entity)))?,
position: world.get::<Position>(entity).copied(),
rotation: world.get::<Rotation>(entity).copied(),
rigid_body: world.get::<RigidBody>(entity).copied().ok_or_else(|| {
format!("{} has no hydrated rigid body", entity_name(world, entity))
})?,
linear_velocity: world.get::<LinearVelocity>(entity).copied(),
angular_velocity: world.get::<AngularVelocity>(entity).copied(),
gravity_scale: world.get::<GravityScale>(entity).copied(),
sleeping: world.get::<Sleeping>(entity).is_some(),
sleeping_disabled: world.get::<SleepingDisabled>(entity).is_some(),
rigid_body_disabled: world.get::<RigidBodyDisabled>(entity).is_some(),
})
}
}
pub struct PhysicsPlacementPlugin;
impl Plugin for PhysicsPlacementPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<PhysicsPlacementState>()
.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<Time<Physics>>) {
physics_time.pause();
}
pub fn begin_physics_placement(
world: &mut World,
selected: impl IntoIterator<Item = Entity>,
) -> Result<(), String> {
if *world.resource::<State<EditorMode>>().get() != EditorMode::Editing {
return placement_error(world, "Physics placement is available only in Edit mode");
}
if world.resource::<PhysicsPlacementState>().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::<Vec<_>>();
validate_selection(world, &selected)?;
let selected_set = selected.iter().copied().collect::<HashSet<_>>();
let selected_snapshots = selected
.iter()
.map(|entity| BodySnapshot::capture(world, *entity))
.collect::<Result<Vec<_>, _>>()?;
let movable = world
.query::<(Entity, &RigidBody)>()
.iter(world)
.filter_map(|(entity, body)| {
(!selected_set.contains(&entity) && *body != RigidBody::Static).then_some(entity)
})
.collect::<Vec<_>>();
let frozen_snapshots = movable
.iter()
.map(|entity| BodySnapshot::capture(world, *entity))
.collect::<Result<Vec<_>, _>>()?;
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::<GlobalTransform>(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::<Sleeping>();
entity.remove::<RigidBodyDisabled>();
}
}
let selected_count = selected_snapshots.len();
let mut state = world.resource_mut::<PhysicsPlacementState>();
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::<PhysicsPlacementState>().active() {
world.resource_mut::<PhysicsPlacementState>().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::<PhysicsPlacementState>() 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::<Transform>(snapshot.entity)
.copied()
.map(|transform| (snapshot.entity, transform))
})
.collect::<Vec<_>>();
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::<PhysicsPlacementPreview>();
}
}
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::<ButtonInput<KeyCode>>()
.is_some_and(|keys| keys.just_pressed(KeyCode::Escape));
let enter = world
.get_resource::<ButtonInput<KeyCode>>()
.is_some_and(|keys| keys.just_pressed(KeyCode::Enter));
let request = world.resource::<PhysicsPlacementState>().request;
let settled = matches!(
world.resource::<PhysicsPlacementState>().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::<PhysicsPlacementState>().phase != PhysicsPlacementPhase::Dropping {
return;
}
for _ in 0..STEPS_PER_FRAME {
world
.resource_mut::<Time<Physics>>()
.advance_by(Duration::from_secs_f64(1.0 / STEP_HZ));
world.run_schedule(FixedPostUpdate);
}
let Some(mut state) = world.remove_resource::<PhysicsPlacementState>() 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::<LinearVelocity>(snapshot.entity)
.map_or(0.0, |velocity| velocity.length());
let angular = world
.get::<AngularVelocity>(snapshot.entity)
.map_or(0.0, |velocity| velocity.length());
(linear <= SETTLE_LINEAR_SPEED && angular <= SETTLE_ANGULAR_SPEED)
|| world.get::<Sleeping>(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::<Sleeping>(&mut entity, snapshot.sleeping);
restore_marker::<SleepingDisabled>(&mut entity, snapshot.sleeping_disabled);
restore_marker::<RigidBodyDisabled>(&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<T: Component + Clone>(entity: &mut EntityWorldMut<'_>, value: Option<T>) {
if let Some(value) = value {
entity.insert(value);
} else {
entity.remove::<T>();
}
}
fn restore_marker<T: Component + Default>(entity: &mut EntityWorldMut<'_>, present: bool) {
if present {
entity.insert(T::default());
} else {
entity.remove::<T>();
}
}
fn placement_error<T>(world: &mut World, message: impl Into<String>) -> Result<T, String> {
let message = message.into();
world.resource_mut::<PhysicsPlacementState>().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<String>,
) {
if let Some(mut operator) = world.get_resource_mut::<ActiveOperator>() {
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::<ActiveOperator>() {
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::<Mesh>()
.init_state::<EditorMode>()
.init_resource::<PhysicsPlacementState>()
.init_resource::<EditorHistory>();
app.finish();
app.cleanup();
app.update();
app.world_mut().resource_mut::<Time<Physics>>().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::<PhysicsPlacementState>().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::<RigidBody>(selected),
Some(&RigidBody::Dynamic)
);
assert_eq!(
app.world().get::<RigidBody>(unrelated),
Some(&RigidBody::Static)
);
for _ in 0..10 {
tick_physics_placement(app.world_mut());
}
assert!(
app.world()
.get::<Transform>(selected)
.unwrap()
.translation
.y
< 4.0
);
cancel_physics_placement(app.world_mut());
assert_eq!(
app.world().get::<Transform>(selected).unwrap().translation,
Vec3::new(1.0, 4.0, 2.0)
);
assert_eq!(
app.world().get::<RigidBody>(selected),
Some(&RigidBody::Kinematic)
);
assert_eq!(
app.world().get::<LinearVelocity>(selected),
Some(&LinearVelocity(Vec3::new(1.0, 2.0, 3.0)))
);
assert_eq!(
app.world().get::<GravityScale>(selected),
Some(&GravityScale(0.25))
);
assert!(app.world().get::<SleepingDisabled>(selected).is_some());
assert_eq!(
app.world().get::<RigidBody>(unrelated),
Some(&RigidBody::Dynamic)
);
assert_eq!(
app.world().get::<LinearVelocity>(unrelated),
Some(&LinearVelocity(Vec3::X * 3.0))
);
assert_eq!(app.world().resource::<EditorHistory>().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::<PhysicsPlacementState>().phase
== PhysicsPlacementPhase::Settled
{
break;
}
}
assert_eq!(
app.world().resource::<PhysicsPlacementState>().phase,
PhysicsPlacementPhase::Settled
);
let settled = *app.world().get::<Transform>(prop).unwrap();
assert!(settled.translation.y < 1.0, "{settled:?}");
commit_physics_placement(app.world_mut());
assert_eq!(app.world().resource::<EditorHistory>().undo_depth(), 1);
assert_eq!(
app.world().resource::<EditorHistory>().status,
"Undo: Move Selection"
);
assert_eq!(app.world().get::<RigidBody>(prop), Some(&RigidBody::Static));
assert_eq!(*app.world().get::<Transform>(prop).unwrap(), settled);
apply_command_undo(app.world_mut());
assert_eq!(*app.world().get::<Transform>(prop).unwrap(), start);
}
}