Add collider authoring diagnostics
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-07-12 22:48:00 -04:00
1 parent 0e7aed40f1
commit 0ce43fc399
19 files changed
+1180 -127

No files matched your search

+73
View File
@@ -15,6 +15,9 @@ use crate::project_io::ProjectWorkspace;
use crate::scene_io::{SceneIo, SceneIoEventSeverity};
use crate::selection::SelectedEntity;
use crate::ui::UiState;
use crate::viewport::collider_diagnostics::{
ColliderDiagnosticSeverity, ColliderDiagnosticsState, ColliderOverlayStatus,
};
#[derive(Resource, Default)]
pub struct DiagnosticsPanel {
@@ -138,6 +141,9 @@ pub fn diagnostics_ui(world: &mut World, ui: &mut egui::Ui) {
}
}
ui.separator();
collider_diagnostics_ui(world, ui);
ui.separator();
ui.horizontal(|ui| {
ui.strong("Support bundle");
@@ -193,6 +199,73 @@ pub fn diagnostics_ui(world: &mut World, ui: &mut egui::Ui) {
ui.small("BRP is enabled on the editor for external tooling.");
}
fn collider_diagnostics_ui(world: &mut World, ui: &mut egui::Ui) {
let Some(state) = world.get_resource::<ColliderDiagnosticsState>() else {
return;
};
let mut rows = state.entries.values().cloned().collect::<Vec<_>>();
rows.sort_by(|left, right| left.actor_name.cmp(&right.actor_name));
let valid = state.valid_actors;
let disabled = state.disabled_actors;
let warnings = state.warning_actors;
let errors = state.error_actors;
ui.horizontal_wrapped(|ui| {
ui.strong("Collider health");
ui.colored_label(
egui::Color32::from_rgb(125, 210, 145),
format!("{valid} ready"),
);
if disabled > 0 {
ui.colored_label(
egui::Color32::from_rgb(143, 151, 163),
format!("{disabled} disabled"),
);
}
if warnings > 0 {
ui.colored_label(
egui::Color32::from_rgb(242, 173, 72),
format!("{warnings} warning"),
);
}
if errors > 0 {
ui.colored_label(
egui::Color32::from_rgb(244, 91, 99),
format!("{errors} invalid"),
);
}
});
for row in rows.into_iter().filter(|row| {
matches!(
row.overlay_status,
ColliderOverlayStatus::Warning | ColliderOverlayStatus::Error
)
}) {
ui.horizontal_wrapped(|ui| {
let color = match row.overlay_status {
ColliderOverlayStatus::Error => egui::Color32::from_rgb(244, 91, 99),
_ => egui::Color32::from_rgb(242, 173, 72),
};
ui.colored_label(color, row.shape_label);
ui.label(&row.actor_name);
if ui.small_button("Select").clicked() {
world.resource_mut::<SelectedEntity>().0 = Some(row.entity);
world
.resource_mut::<UiState>()
.selected_entities
.select_replace(row.entity);
}
});
for diagnostic in &row.diagnostics {
if diagnostic.severity == ColliderDiagnosticSeverity::Info {
continue;
}
ui.small(format!("{}: {}", diagnostic.code, diagnostic.message));
}
}
}
pub fn brush_diagnostics_window(world: &mut World, ctx: &egui::Context, open: &mut bool) {
if !*open {
return;
+118 -11
View File
@@ -44,6 +44,9 @@ use crate::ui::theme::{
};
use crate::ui::widgets::{icon_button_small, phosphor_icon, phosphor_icon_text};
use crate::viewport::brush_edit::{BrushElementKey, BrushElementSelection};
use crate::viewport::collider_diagnostics::{
diagnose_collider, ColliderDiagnosticSeverity, ColliderOverlayStatus,
};
use super::component_registry::{
EditorComponentCategory, EditorComponentDescriptor, EditorComponentRegistry,
@@ -4213,6 +4216,7 @@ fn rigid_body_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
fn collider_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
let mesh_candidates = static_mesh_asset_ref_candidates(world, AssetRefCandidateKind::Mesh);
let diagnostic_entry = diagnose_collider(world, entity);
let Some(mut collider) = world.get::<ColliderDesc>(entity).cloned() else {
return;
};
@@ -4235,13 +4239,60 @@ fn collider_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
ComponentCardOptions::removable(COMPONENT_COLLIDER_DESC, "Collider", icons::SELECTION),
);
let card_response = component_card(ui, &card, |ui| {
if let Some(entry) = diagnostic_entry.as_ref() {
let (label, color) = match entry.overlay_status {
ColliderOverlayStatus::Valid => ("Ready", egui::Color32::from_rgb(112, 210, 144)),
ColliderOverlayStatus::Trigger => {
("Trigger", egui::Color32::from_rgb(86, 195, 235))
}
ColliderOverlayStatus::Disabled => {
("Disabled", egui::Color32::from_rgb(143, 151, 163))
}
ColliderOverlayStatus::Warning => {
("Warning", egui::Color32::from_rgb(242, 173, 72))
}
ColliderOverlayStatus::Error => ("Invalid", egui::Color32::from_rgb(244, 91, 99)),
};
ui.horizontal_wrapped(|ui| {
ui.colored_label(color, egui::RichText::new(label).strong());
ui.label(egui::RichText::new(entry.shape_label).color(TEXT_DIM));
if entry.runtime_ready {
ui.label(egui::RichText::new("Hydrated").color(TEXT_MUTED).small());
}
});
for diagnostic in &entry.diagnostics {
let color = match diagnostic.severity {
ColliderDiagnosticSeverity::Info => TEXT_MUTED,
ColliderDiagnosticSeverity::Warning => egui::Color32::from_rgb(242, 173, 72),
ColliderDiagnosticSeverity::Error => egui::Color32::from_rgb(244, 91, 99),
};
ui.label(
egui::RichText::new(&diagnostic.message)
.color(color)
.small(),
);
ui.label(
egui::RichText::new(&diagnostic.repair)
.color(TEXT_MUTED)
.small(),
);
}
if entry.highest_severity() == Some(ColliderDiagnosticSeverity::Error)
&& ui.small_button("Reset shape").clicked()
{
collider.shape = ColliderShapeDesc::default();
collider.enabled = true;
changed = true;
}
ui.add_space(2.0);
}
property_row(ui, "Mode", |ui| {
changed |= ui.checkbox(&mut collider.enabled, "Enabled").changed();
changed |= ui.checkbox(&mut collider.is_trigger, "Trigger").changed();
});
property_row(ui, "Shape", |ui| {
let mut shape_kind = collider_shape_kind(&collider.shape);
egui::ComboBox::from_id_salt("collider_shape_kind")
egui::ComboBox::from_id_salt(("collider_shape_kind", entity))
.selected_text(shape_kind)
.show_ui(ui, |ui| {
for label in ["Box", "Sphere", "Capsule", "Static Mesh"] {
@@ -4251,15 +4302,8 @@ fn collider_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
}
});
if shape_kind != collider_shape_kind(&collider.shape) {
collider.shape = match shape_kind {
"Sphere" => ColliderShapeDesc::Sphere { radius: 0.5 },
"Capsule" => ColliderShapeDesc::Capsule {
radius: 0.5,
height: 1.0,
},
"Static Mesh" => ColliderShapeDesc::static_mesh(renderer_meshes.clone()),
_ => ColliderShapeDesc::default(),
};
collider.shape =
convert_collider_shape(&collider.shape, shape_kind, renderer_meshes.clone());
changed = true;
}
});
@@ -4327,12 +4371,48 @@ fn collider_shape_kind(shape: &ColliderShapeDesc) -> &'static str {
}
}
fn convert_collider_shape(
previous: &ColliderShapeDesc,
shape_kind: &str,
renderer_meshes: Vec<EditorAssetRef>,
) -> ColliderShapeDesc {
let dimensions = match previous {
ColliderShapeDesc::Cuboid {
x_length,
y_length,
z_length,
} => Vec3::new(*x_length, *y_length, *z_length),
ColliderShapeDesc::Sphere { radius } => Vec3::splat(*radius * 2.0),
ColliderShapeDesc::Capsule { radius, height } => {
Vec3::new(*radius * 2.0, *height, *radius * 2.0)
}
ColliderShapeDesc::StaticMesh { .. } => Vec3::ONE,
}
.max(Vec3::splat(0.001));
match shape_kind {
"Sphere" => ColliderShapeDesc::Sphere {
radius: dimensions.max_element() * 0.5,
},
"Capsule" => ColliderShapeDesc::Capsule {
radius: dimensions.x.max(dimensions.z) * 0.5,
height: dimensions.y,
},
"Static Mesh" => ColliderShapeDesc::static_mesh(renderer_meshes),
_ => ColliderShapeDesc::Cuboid {
x_length: dimensions.x,
y_length: dimensions.y,
z_length: dimensions.z,
},
}
}
fn dimension_drag(ui: &mut egui::Ui, label: &str, value: &mut f32) -> bool {
property_row(ui, label, |ui| {
ui.add_sized(
[fit_width(ui, 72.0, 120.0), 20.0],
egui::DragValue::new(value)
.range(0.0..=10_000.0)
.range(0.001..=10_000.0)
.speed(0.05)
.min_decimals(2)
.max_decimals(3),
@@ -4839,3 +4919,30 @@ fn option_string_ui(ui: &mut egui::Ui, label: &str, value: &mut Option<String>)
};
changed
}
#[cfg(test)]
mod collider_inspector_tests {
use super::*;
use crate::history::{apply_command_undo, EditorHistory};
#[test]
fn shape_switch_preserves_dimensions_and_is_one_undoable_edit() {
let mut world = World::new();
world.init_resource::<EditorHistory>();
let original = ColliderDesc::static_cuboid(Vec3::new(2.0, 4.0, 6.0));
let entity = world.spawn((LevelObject, original.clone())).id();
let sphere = ColliderDesc {
shape: convert_collider_shape(&original.shape, "Sphere", Vec::new()),
..original.clone()
};
assert_eq!(sphere.shape, ColliderShapeDesc::Sphere { radius: 3.0 });
set_collider_with_history(&mut world, entity, sphere.clone());
assert_eq!(world.resource::<EditorHistory>().undo_depth(), 1);
assert_eq!(world.get::<ColliderDesc>(entity), Some(&sphere));
apply_command_undo(&mut world);
assert_eq!(world.get::<ColliderDesc>(entity), Some(&original));
}
}
+43 -5
View File
@@ -15,7 +15,7 @@ use crate::assets::{AssetSelection, AssetSubAssetKind, EditorAssets};
use crate::camera::EditorCamera;
use crate::gizmos::{EditorGizmoMode, EditorGizmoSpace};
use crate::render_target::ViewportRenderTarget;
use crate::selection::{ViewportClick, ViewportPickStack};
use crate::selection::{SelectedEntity, ViewportClick, ViewportPickStack};
use crate::state::PlayPossession;
use crate::viewport::actor_icons::ActorIconSettings;
use crate::viewport::brush_edit::{BrushEditMode, BrushElementSelection};
@@ -200,16 +200,54 @@ fn scene_view_render_badge(world: &World, ctx: &egui::Context, scene_rect: egui:
});
if mode == EditorViewportMode::Collider {
let health =
world.get_resource::<crate::viewport::collider_diagnostics::ColliderDiagnosticsState>();
let selected_entry = world
.get_resource::<SelectedEntity>()
.and_then(|selected| selected.0)
.and_then(|entity| health.and_then(|health| health.entry(entity)));
egui::Area::new(egui::Id::new("scene_view_collider_warning"))
.fixed_pos(scene_rect.left_bottom() + egui::vec2(8.0, -28.0))
.interactable(false)
.show(ctx, |ui| {
overlay_chip_frame().show(ui, |ui| {
ui.label(
egui::RichText::new("Collider view / meshes hidden")
.color(WARNING)
ui.horizontal_wrapped(|ui| {
ui.label(
egui::RichText::new("Collider View")
.color(WARNING)
.strong()
.small(),
);
if let Some(health) = health {
ui.label(
egui::RichText::new(format!(
"{} ready {} disabled {} warning {} invalid",
health.valid_actors,
health.disabled_actors,
health.warning_actors,
health.error_actors
))
.color(TEXT_MUTED)
.small(),
);
}
});
if let Some(entry) = selected_entry {
ui.label(
egui::RichText::new(format!(
"{} / {} / {}",
entry.actor_name,
entry.shape_label,
if entry.runtime_ready {
"hydrated"
} else {
"not hydrated"
}
))
.color(SELECTION)
.small(),
);
);
}
});
});
}
@@ -0,0 +1,428 @@
//! Shared authored/runtime collider diagnostics for editor workflows.
use std::collections::HashMap;
use avian3d::prelude::{Collider, RigidBody};
use bevy::prelude::*;
use shared::{
authoring_component_active, AuthoringComponentStates, ColliderDesc, ColliderShapeDesc,
InspectorOrder, LevelObject, PhysicsBody, RigidBodyDesc, COMPONENT_COLLIDER_DESC,
COMPONENT_PHYSICS_BODY, COMPONENT_RIGID_BODY_DESC,
};
use crate::assets::asset_db::{find_asset_by_id, AssetRegistry};
use crate::ui::selection_ops::entity_name;
/// Collider dimensions beyond this world-space extent are usually accidental in a meter-scale
/// project and can severely degrade broad-phase performance.
pub const OVERSIZED_COLLIDER_EXTENT: f32 = 1_000.0;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum ColliderDiagnosticSeverity {
Info,
Warning,
Error,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ColliderDiagnostic {
pub code: &'static str,
pub severity: ColliderDiagnosticSeverity,
pub message: String,
pub repair: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ColliderOverlayStatus {
Valid,
Trigger,
Disabled,
Warning,
Error,
}
#[derive(Debug, Clone)]
pub struct ColliderDiagnosticEntry {
pub entity: Entity,
pub actor_name: String,
pub shape_label: &'static str,
pub runtime_ready: bool,
pub diagnostics: Vec<ColliderDiagnostic>,
pub overlay_status: ColliderOverlayStatus,
}
impl ColliderDiagnosticEntry {
pub fn highest_severity(&self) -> Option<ColliderDiagnosticSeverity> {
self.diagnostics
.iter()
.map(|diagnostic| diagnostic.severity)
.max()
}
pub fn blocking_messages(&self) -> impl Iterator<Item = &str> {
self.diagnostics
.iter()
.filter(|diagnostic| diagnostic.severity == ColliderDiagnosticSeverity::Error)
.map(|diagnostic| diagnostic.message.as_str())
}
}
#[derive(Resource, Debug, Default)]
pub struct ColliderDiagnosticsState {
pub entries: HashMap<Entity, ColliderDiagnosticEntry>,
pub valid_actors: usize,
pub disabled_actors: usize,
pub warning_actors: usize,
pub error_actors: usize,
}
impl ColliderDiagnosticsState {
pub fn entry(&self, entity: Entity) -> Option<&ColliderDiagnosticEntry> {
self.entries.get(&entity)
}
}
pub fn refresh_collider_diagnostics(world: &mut World) {
let entities = world
.iter_entities()
.filter(|entity| entity.contains::<LevelObject>())
.map(|entity| entity.id())
.collect::<Vec<_>>();
let mut state = ColliderDiagnosticsState::default();
for entity in entities {
let Some(entry) = diagnose_collider(world, entity) else {
continue;
};
match entry.overlay_status {
ColliderOverlayStatus::Error => state.error_actors += 1,
ColliderOverlayStatus::Warning => state.warning_actors += 1,
ColliderOverlayStatus::Disabled => state.disabled_actors += 1,
_ => state.valid_actors += 1,
}
state.entries.insert(entity, entry);
}
world.insert_resource(state);
}
pub fn diagnose_collider(world: &World, entity: Entity) -> Option<ColliderDiagnosticEntry> {
let states = world.get::<AuthoringComponentStates>(entity);
let order = world.get::<InspectorOrder>(entity);
let rigid_body_active = world.get::<RigidBodyDesc>(entity).is_some()
&& authoring_component_active(states, order, COMPONENT_RIGID_BODY_DESC);
let legacy_active = world.get::<PhysicsBody>(entity).is_some()
&& authoring_component_active(states, order, COMPONENT_PHYSICS_BODY);
let collider = world.get::<ColliderDesc>(entity);
let collider_active =
collider.is_some() && authoring_component_active(states, order, COMPONENT_COLLIDER_DESC);
if !rigid_body_active && !legacy_active && collider.is_none() {
return None;
}
let mut diagnostics = Vec::new();
if rigid_body_active && !legacy_active && !collider_active {
diagnostics.push(ColliderDiagnostic {
code: "collider.missing",
severity: ColliderDiagnosticSeverity::Error,
message: "Rigid body has no active Collider component.".into(),
repair: "Add or enable a Collider component on this actor.".into(),
});
}
let mut shape_label = if legacy_active { "Legacy" } else { "Missing" };
let mut enabled = legacy_active;
let mut trigger = false;
let mut authoring_valid = true;
if let Some(collider) = collider {
shape_label = collider_shape_label(&collider.shape);
enabled = collider_active && collider.enabled;
trigger = collider.is_trigger;
if !collider_active {
diagnostics.push(ColliderDiagnostic {
code: "collider.inactive",
severity: ColliderDiagnosticSeverity::Info,
message: "Collider component is inactive.".into(),
repair: "Enable the component when this actor should participate in collision."
.into(),
});
} else if !collider.enabled {
diagnostics.push(ColliderDiagnostic {
code: "collider.disabled",
severity: ColliderDiagnosticSeverity::Info,
message: "Collider is disabled.".into(),
repair: "Enable the collider when collision is required.".into(),
});
} else {
let shape_diagnostics = validate_shape(world, entity, &collider.shape);
authoring_valid = shape_diagnostics
.iter()
.all(|diagnostic| diagnostic.severity != ColliderDiagnosticSeverity::Error);
diagnostics.extend(shape_diagnostics);
}
}
let runtime_ready = has_runtime_collider(world, entity);
if enabled && authoring_valid && !runtime_ready {
diagnostics.push(ColliderDiagnostic {
code: "collider.runtime_stale",
severity: ColliderDiagnosticSeverity::Warning,
message: "Authored collider has not hydrated into a runtime shape.".into(),
repair: "Check mesh cooking and asset references, then refresh the scene.".into(),
});
}
let highest = diagnostics
.iter()
.map(|diagnostic| diagnostic.severity)
.max();
let overlay_status = match highest {
Some(ColliderDiagnosticSeverity::Error) => ColliderOverlayStatus::Error,
Some(ColliderDiagnosticSeverity::Warning) => ColliderOverlayStatus::Warning,
_ if !enabled => ColliderOverlayStatus::Disabled,
_ if trigger => ColliderOverlayStatus::Trigger,
_ => ColliderOverlayStatus::Valid,
};
Some(ColliderDiagnosticEntry {
entity,
actor_name: entity_name(world, entity),
shape_label,
runtime_ready,
diagnostics,
overlay_status,
})
}
pub fn physics_placement_prerequisite_problems(world: &World, entity: Entity) -> Vec<String> {
let name = entity_name(world, entity);
let states = world.get::<AuthoringComponentStates>(entity);
let order = world.get::<InspectorOrder>(entity);
let split_body = world.get::<RigidBodyDesc>(entity).is_some()
&& authoring_component_active(states, order, COMPONENT_RIGID_BODY_DESC);
let legacy = world.get::<PhysicsBody>(entity).is_some()
&& authoring_component_active(states, order, COMPONENT_PHYSICS_BODY);
let collider = world.get::<ColliderDesc>(entity).filter(|collider| {
collider.enabled
&& !collider.is_trigger
&& authoring_component_active(states, order, COMPONENT_COLLIDER_DESC)
});
let mut problems = Vec::new();
if !split_body && !legacy {
problems.push(format!("{name}: add and enable a Rigid Body component"));
}
if collider.is_none() && !legacy {
problems.push(format!(
"{name}: add and enable a non-trigger Collider component"
));
}
if let Some(entry) = diagnose_collider(world, entity) {
problems.extend(
entry
.diagnostics
.iter()
.filter(|diagnostic| {
diagnostic.severity == ColliderDiagnosticSeverity::Error
&& diagnostic.code != "collider.missing"
})
.map(|diagnostic| format!("{name}: {}", diagnostic.message)),
);
}
if world.get::<RigidBody>(entity).is_none() {
problems.push(format!("{name}: rigid body has not hydrated yet"));
}
if !has_runtime_collider(world, entity) {
problems.push(format!(
"{name}: collider has not hydrated or finished cooking"
));
}
problems.sort();
problems.dedup();
problems
}
pub fn has_runtime_collider(world: &World, root: Entity) -> bool {
let mut pending = vec![root];
while let Some(entity) = pending.pop() {
if world.get::<Collider>(entity).is_some() {
return true;
}
if let Some(children) = world.get::<Children>(entity) {
pending.extend(children.iter());
}
}
false
}
pub fn collider_shape_label(shape: &ColliderShapeDesc) -> &'static str {
match shape {
ColliderShapeDesc::Cuboid { .. } => "Box",
ColliderShapeDesc::Sphere { .. } => "Sphere",
ColliderShapeDesc::Capsule { .. } => "Capsule",
ColliderShapeDesc::StaticMesh { .. } => "Static Mesh",
}
}
fn validate_shape(
world: &World,
entity: Entity,
shape: &ColliderShapeDesc,
) -> Vec<ColliderDiagnostic> {
let mut diagnostics = Vec::new();
let dimensions = match shape {
ColliderShapeDesc::Cuboid {
x_length,
y_length,
z_length,
} => Some(Vec3::new(*x_length, *y_length, *z_length)),
ColliderShapeDesc::Sphere { radius } => Some(Vec3::splat(*radius * 2.0)),
ColliderShapeDesc::Capsule { radius, height } => {
Some(Vec3::new(*radius * 2.0, *height, *radius * 2.0))
}
ColliderShapeDesc::StaticMesh { meshes, .. } => {
if meshes.is_empty() {
diagnostics.push(ColliderDiagnostic {
code: "collider.mesh_missing",
severity: ColliderDiagnosticSeverity::Error,
message: "Static mesh collider has no mesh sources.".into(),
repair: "Choose a mesh source or use the actor renderer meshes.".into(),
});
}
for mesh in meshes {
if !mesh.is_resolved() {
diagnostics.push(ColliderDiagnostic {
code: "collider.mesh_invalid_ref",
severity: ColliderDiagnosticSeverity::Error,
message: format!(
"Static mesh source `{}` has no stable asset or sub-asset ID.",
mesh.label
),
repair: "Choose a valid mesh from the asset browser.".into(),
});
} else if world
.get_resource::<AssetRegistry>()
.is_some_and(|registry| find_asset_by_id(registry, &mesh.asset_id).is_none())
{
diagnostics.push(ColliderDiagnostic {
code: "collider.mesh_stale_ref",
severity: ColliderDiagnosticSeverity::Error,
message: format!(
"Static mesh source `{}` no longer exists in the asset registry.",
mesh.label
),
repair: "Relink the collider to an existing mesh asset.".into(),
});
}
}
None
}
};
if let Some(dimensions) = dimensions {
if !dimensions.is_finite() || dimensions.min_element() <= 0.0 {
diagnostics.push(ColliderDiagnostic {
code: "collider.invalid_dimensions",
severity: ColliderDiagnosticSeverity::Error,
message: "Collider dimensions must be positive finite values.".into(),
repair: "Reset the shape or enter valid dimensions.".into(),
});
} else {
let scale = world
.get::<GlobalTransform>(entity)
.map(|global| global.to_scale_rotation_translation().0.abs())
.unwrap_or(Vec3::ONE);
let world_extent = (dimensions * scale).max_element();
if world_extent > OVERSIZED_COLLIDER_EXTENT {
diagnostics.push(ColliderDiagnostic {
code: "collider.oversized",
severity: ColliderDiagnosticSeverity::Warning,
message: format!(
"Collider spans {world_extent:.1} m in world space (recommended maximum: {OVERSIZED_COLLIDER_EXTENT:.0} m)."
),
repair: "Reduce collider dimensions or actor scale; split large collision into smaller actors."
.into(),
});
}
}
}
diagnostics
}
#[cfg(test)]
mod tests {
use super::*;
use shared::AuthoringRigidBody;
#[test]
fn reports_missing_invalid_oversized_and_stale_runtime_colliders() {
let mut world = World::new();
let missing = world
.spawn((LevelObject, RigidBodyDesc::default(), Transform::default()))
.id();
let invalid = world
.spawn((
LevelObject,
ColliderDesc {
enabled: true,
is_trigger: false,
shape: ColliderShapeDesc::Sphere { radius: 0.0 },
},
Transform::default(),
))
.id();
let oversized = world
.spawn((
LevelObject,
ColliderDesc::static_cuboid(Vec3::splat(2.0)),
Transform::from_scale(Vec3::splat(600.0)),
GlobalTransform::from(Transform::from_scale(Vec3::splat(600.0))),
))
.id();
let missing = diagnose_collider(&world, missing).unwrap();
assert!(missing
.diagnostics
.iter()
.any(|diagnostic| diagnostic.code == "collider.missing"));
let invalid = diagnose_collider(&world, invalid).unwrap();
assert!(invalid
.diagnostics
.iter()
.any(|diagnostic| diagnostic.code == "collider.invalid_dimensions"));
let oversized = diagnose_collider(&world, oversized).unwrap();
assert!(oversized
.diagnostics
.iter()
.any(|diagnostic| diagnostic.code == "collider.oversized"));
assert!(oversized
.diagnostics
.iter()
.any(|diagnostic| diagnostic.code == "collider.runtime_stale"));
}
#[test]
fn hydrated_trigger_has_trigger_overlay_status() {
let mut world = World::new();
let entity = world
.spawn((
LevelObject,
RigidBodyDesc {
body: AuthoringRigidBody::Static,
},
ColliderDesc {
enabled: true,
is_trigger: true,
shape: ColliderShapeDesc::Sphere { radius: 1.0 },
},
Collider::sphere(1.0),
Transform::default(),
))
.id();
let entry = diagnose_collider(&world, entity).unwrap();
assert_eq!(entry.overlay_status, ColliderOverlayStatus::Trigger);
assert!(entry.runtime_ready);
}
}
+1
View File
@@ -5,6 +5,7 @@ pub mod brush_csg;
pub mod brush_edit;
pub mod brush_tool;
pub mod camera;
pub mod collider_diagnostics;
pub mod gizmos;
pub mod material_drop;
mod panel;
@@ -5,16 +5,12 @@ use std::time::Duration;
use avian3d::prelude::*;
use bevy::prelude::*;
use shared::{
authoring_component_active, AuthoringComponentStates, ColliderDesc, InspectorOrder,
PhysicsBody, RigidBodyDesc, COMPONENT_COLLIDER_DESC, COMPONENT_PHYSICS_BODY,
COMPONENT_RIGID_BODY_DESC,
};
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;
@@ -369,33 +365,7 @@ fn validate_selection(world: &mut World, selected: &[Entity]) -> Result<(), Stri
));
continue;
}
let states = world.get::<AuthoringComponentStates>(*entity);
let order = world.get::<InspectorOrder>(*entity);
let split_body = world.get::<RigidBodyDesc>(*entity).is_some()
&& authoring_component_active(states, order, COMPONENT_RIGID_BODY_DESC);
let split_collider = world.get::<ColliderDesc>(*entity).filter(|collider| {
collider.enabled
&& !collider.is_trigger
&& authoring_component_active(states, order, COMPONENT_COLLIDER_DESC)
});
let legacy = world.get::<PhysicsBody>(*entity).is_some()
&& authoring_component_active(states, order, COMPONENT_PHYSICS_BODY);
if !split_body && !legacy {
problems.push(format!("{name}: add and enable a Rigid Body component"));
}
if split_collider.is_none() && !legacy {
problems.push(format!(
"{name}: add and enable a non-trigger Collider component"
));
}
if world.get::<RigidBody>(*entity).is_none() {
problems.push(format!("{name}: rigid body has not hydrated yet"));
}
if !has_runtime_collider(world, *entity) {
problems.push(format!(
"{name}: collider has not hydrated or finished cooking"
));
}
problems.extend(physics_placement_prerequisite_problems(world, *entity));
}
if problems.is_empty() {
Ok(())
@@ -404,19 +374,6 @@ fn validate_selection(world: &mut World, selected: &[Entity]) -> Result<(), Stri
}
}
fn has_runtime_collider(world: &World, root: Entity) -> bool {
let mut pending = vec![root];
while let Some(entity) = pending.pop() {
if world.get::<Collider>(entity).is_some() {
return true;
}
if let Some(children) = world.get::<Children>(entity) {
pending.extend(children.iter());
}
}
false
}
fn restore_snapshot(world: &mut World, snapshot: &BodySnapshot, restore_pose: bool) {
let Ok(mut entity) = world.get_entity_mut(snapshot.entity) else {
return;
@@ -498,7 +455,7 @@ mod tests {
use crate::history::{apply_command_undo, EditorHistory};
use bevy::asset::{AssetApp, AssetPlugin};
use bevy::state::app::StatesPlugin;
use shared::LevelObject;
use shared::{ColliderDesc, LevelObject, RigidBodyDesc};
fn app_with_physics() -> App {
let mut app = App::new();
+194 -61
View File
@@ -1,14 +1,16 @@
//! Editor-side scene visualizers for authoring/runtime entities that have no mesh.
use avian3d::prelude::ColliderConstructor;
use std::f32::consts::FRAC_PI_2;
use avian3d::prelude::{ColliderAabb, ColliderConstructor};
use bevy::ecs::system::SystemParam;
use bevy::prelude::*;
use shared::{
AudioListenerDesc, AudioSourceDesc, AuthoringLightKind, ColliderDesc, ColliderShapeDesc,
LevelObject, LightDesc, ModelRef, NavigationArea, NavigationBounds, NavigationLink,
NavigationObstacle, ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc,
PrefabRef, ProjectSun, RaytracingExcluded, SkinnedMeshRenderer, TeamSpawn, TriggerVolume,
WeaponSpawn,
PrefabRef, ProjectSun, RaytracingExcluded, RigidBodyDesc, SkinnedMeshRenderer, TeamSpawn,
TriggerVolume, WeaponSpawn,
};
use sim::tuning::{EYE_OFFSET_STAND, PLAYER_LENGTH, PLAYER_RADIUS};
use sim::{Player, PlayerCamera};
@@ -16,6 +18,10 @@ use sim::{Player, PlayerCamera};
use crate::infra::EditorOnly;
use crate::selection::SelectedEntity;
use crate::state::{scene_tools_active, EditorMode, PlayPossession};
use crate::viewport::collider_diagnostics::{
refresh_collider_diagnostics, ColliderDiagnosticEntry, ColliderDiagnosticsState,
ColliderOverlayStatus,
};
use crate::viewport::{EditorViewportMode, ViewportDisplayMode};
#[derive(Resource, Debug, Clone)]
@@ -102,7 +108,7 @@ struct VisualizerTargetQueries<'w, 's> {
Entity,
(
With<LevelObject>,
Or<(With<PhysicsBody>, With<ColliderDesc>)>,
Or<(With<PhysicsBody>, With<ColliderDesc>, With<RigidBodyDesc>)>,
),
>,
lights: Query<'w, 's, Entity, (With<LevelObject>, With<LightDesc>)>,
@@ -127,7 +133,15 @@ pub struct EditorVisualizersPlugin;
impl Plugin for EditorVisualizersPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<EditorVisualizationSettings>()
.init_resource::<ColliderDiagnosticsState>()
.add_systems(Startup, init_visualizer_proxy_assets)
.add_systems(
Update,
refresh_collider_diagnostics
.before(sync_visualizer_proxies)
.before(draw_visualizers)
.before(draw_split_collider_visualizers),
)
.add_systems(Update, sync_visualizer_proxies)
.add_systems(
Update,
@@ -135,6 +149,7 @@ impl Plugin for EditorVisualizersPlugin {
draw_visualizers,
draw_audio_visualizers,
draw_split_collider_visualizers,
draw_missing_collider_visualizers,
draw_post_process_volume_gizmos,
draw_navigation_visualizers,
)
@@ -145,6 +160,52 @@ impl Plugin for EditorVisualizersPlugin {
}
}
fn draw_missing_collider_visualizers(
viewport_mode: Res<EditorViewportMode>,
settings: Res<EditorVisualizationSettings>,
diagnostics: Res<ColliderDiagnosticsState>,
selected: Res<SelectedEntity>,
mut gizmos: Gizmos,
missing: Query<
(Entity, &GlobalTransform),
(
With<LevelObject>,
With<RigidBodyDesc>,
Without<ColliderDesc>,
Without<PhysicsBody>,
),
>,
) {
let collider_mode = *viewport_mode == EditorViewportMode::Collider;
if !(collider_mode || settings.enabled && settings.show_colliders) {
return;
}
for (entity, global) in &missing {
let color = collider_overlay_color(
diagnostics.entry(entity),
selected.0 == Some(entity),
collider_mode,
);
let center = global.translation();
let radius = if selected.0 == Some(entity) {
0.48
} else {
0.34
};
draw_box(
&mut gizmos,
center,
global.rotation(),
Vec3::splat(radius),
color,
);
for axis in [Vec3::X, Vec3::Y, Vec3::Z] {
let direction = global.rotation() * axis * radius * 1.35;
gizmos.line(center - direction, center + direction, color);
}
}
}
fn draw_navigation_visualizers(
state: Res<crate::ui::navigation_inspector::NavigationEditorState>,
mut gizmos: Gizmos,
@@ -556,17 +617,7 @@ fn draw_visualizers(
if settings.show_colliders || collider_mode {
for (entity, body, global) in &colliders {
let color = if selected.0 == Some(entity) {
if collider_mode {
Color::srgba(0.65, 1.0, 0.55, 1.0)
} else {
Color::srgba(0.55, 1.0, 0.45, 0.95)
}
} else if collider_mode {
Color::srgba(0.35, 1.0, 0.45, 0.9)
} else {
Color::srgba(0.25, 0.9, 0.35, 0.55)
};
let color = collider_overlay_color(None, selected.0 == Some(entity), collider_mode);
draw_collider(&mut gizmos, global, &body.collider, color);
}
}
@@ -679,11 +730,18 @@ fn draw_visualizers(
}
}
#[expect(
clippy::too_many_arguments,
reason = "collider overlays combine authoring, runtime bounds, selection, and viewport state"
)]
fn draw_split_collider_visualizers(
viewport_mode: Res<EditorViewportMode>,
settings: Res<EditorVisualizationSettings>,
diagnostics: Res<ColliderDiagnosticsState>,
selected: Res<SelectedEntity>,
mut gizmos: Gizmos,
children: Query<&Children>,
runtime_aabbs: Query<&ColliderAabb>,
colliders: Query<
(Entity, &ColliderDesc, &GlobalTransform),
(With<LevelObject>, Without<PhysicsBody>),
@@ -697,17 +755,80 @@ fn draw_split_collider_visualizers(
return;
}
for (entity, collider, global) in &colliders {
let color = if selected.0 == Some(entity) {
Color::srgba(0.65, 1.0, 0.55, 1.0)
} else if collider_mode {
Color::srgba(0.35, 1.0, 0.45, 0.9)
} else {
Color::srgba(0.25, 0.9, 0.35, 0.55)
};
draw_collider_desc(&mut gizmos, global, collider, color);
let color = collider_overlay_color(
diagnostics.entry(entity),
selected.0 == Some(entity),
collider_mode,
);
let drew_runtime_mesh = matches!(collider.shape, ColliderShapeDesc::StaticMesh { .. })
&& draw_runtime_collider_bounds(&mut gizmos, entity, &children, &runtime_aabbs, color);
if !drew_runtime_mesh {
draw_collider_desc(&mut gizmos, global, collider, color);
}
}
}
fn collider_overlay_color(
entry: Option<&ColliderDiagnosticEntry>,
selected: bool,
collider_mode: bool,
) -> Color {
let status = entry
.map(|entry| entry.overlay_status)
.unwrap_or(ColliderOverlayStatus::Valid);
let (rgb, base_alpha): (Vec3, f32) = match status {
ColliderOverlayStatus::Valid => (Vec3::new(0.25, 0.92, 0.43), 0.72),
ColliderOverlayStatus::Trigger => (Vec3::new(0.18, 0.82, 1.0), 0.78),
ColliderOverlayStatus::Disabled => (Vec3::new(0.52, 0.56, 0.62), 0.42),
ColliderOverlayStatus::Warning => (Vec3::new(1.0, 0.68, 0.18), 0.9),
ColliderOverlayStatus::Error => (Vec3::new(1.0, 0.24, 0.3), 0.96),
};
let alpha = if selected {
1.0
} else if collider_mode {
base_alpha.max(0.82)
} else {
base_alpha * 0.72
};
let rgb = if selected {
rgb.lerp(Vec3::ONE, 0.18)
} else {
rgb
};
Color::srgba(rgb.x, rgb.y, rgb.z, alpha)
}
fn draw_runtime_collider_bounds(
gizmos: &mut Gizmos,
root: Entity,
children: &Query<&Children>,
aabbs: &Query<&ColliderAabb>,
color: Color,
) -> bool {
let mut pending = vec![root];
let mut drew = false;
while let Some(entity) = pending.pop() {
if let Ok(aabb) = aabbs.get(entity) {
let min = aabb.min;
let max = aabb.max;
if min.is_finite() && max.is_finite() && min.cmplt(max).all() {
draw_box(
gizmos,
(min + max) * 0.5,
Quat::IDENTITY,
(max - min) * 0.5,
color,
);
drew = true;
}
}
if let Ok(entity_children) = children.get(entity) {
pending.extend(entity_children.iter());
}
}
drew
}
fn draw_post_process_volume_gizmos(
viewport_mode: Res<EditorViewportMode>,
settings: Res<EditorVisualizationSettings>,
@@ -741,6 +862,8 @@ fn draw_collider(
collider: &ColliderConstructor,
color: Color,
) {
let (scale, rotation, translation) = global.to_scale_rotation_translation();
let scale = scale.abs();
match collider {
ColliderConstructor::Cuboid {
x_length,
@@ -748,27 +871,21 @@ fn draw_collider(
z_length,
} => draw_box(
gizmos,
global.translation(),
global.rotation(),
Vec3::new(*x_length, *y_length, *z_length) * 0.5,
translation,
rotation,
Vec3::new(*x_length, *y_length, *z_length) * scale * 0.5,
color,
),
ColliderConstructor::Sphere { radius } => {
gizmos
.sphere(
Isometry3d::new(global.translation(), global.rotation()),
*radius,
color,
)
.resolution(24);
draw_ellipsoid(gizmos, translation, rotation, scale * *radius, color);
}
ColliderConstructor::Capsule { radius, height } => {
draw_capsule(
gizmos,
global.translation(),
global.rotation(),
*radius,
*height,
translation,
rotation,
*radius * scale.x.max(scale.z),
*height * scale.y,
color,
);
}
@@ -790,9 +907,8 @@ fn draw_collider_desc(
collider: &ColliderDesc,
color: Color,
) {
if !collider.enabled {
return;
}
let (scale, rotation, translation) = global.to_scale_rotation_translation();
let scale = scale.abs();
match &collider.shape {
ColliderShapeDesc::Cuboid {
x_length,
@@ -800,42 +916,59 @@ fn draw_collider_desc(
z_length,
} => draw_box(
gizmos,
global.translation(),
global.rotation(),
Vec3::new(*x_length, *y_length, *z_length) * 0.5,
translation,
rotation,
Vec3::new(*x_length, *y_length, *z_length) * scale * 0.5,
color,
),
ColliderShapeDesc::Sphere { radius } => {
gizmos
.sphere(
Isometry3d::new(global.translation(), global.rotation()),
*radius,
color,
)
.resolution(24);
draw_ellipsoid(gizmos, translation, rotation, scale * *radius, color);
}
ColliderShapeDesc::Capsule { radius, height } => {
draw_capsule(
gizmos,
global.translation(),
global.rotation(),
*radius,
*height,
translation,
rotation,
*radius * scale.x.max(scale.z),
*height * scale.y,
color,
);
}
ColliderShapeDesc::StaticMesh { .. } => {
gizmos
.sphere(
Isometry3d::new(global.translation(), global.rotation()),
0.35,
color,
)
.resolution(16);
draw_box(gizmos, translation, rotation, Vec3::splat(0.24), color);
gizmos.line(
translation - rotation * Vec3::splat(0.34),
translation + rotation * Vec3::splat(0.34),
color,
);
}
}
}
fn draw_ellipsoid(gizmos: &mut Gizmos, center: Vec3, rotation: Quat, radii: Vec3, color: Color) {
gizmos
.ellipse(
Isometry3d::new(center, rotation),
Vec2::new(radii.x, radii.z),
color,
)
.resolution(32);
gizmos
.ellipse(
Isometry3d::new(center, rotation * Quat::from_rotation_x(FRAC_PI_2)),
Vec2::new(radii.x, radii.y),
color,
)
.resolution(32);
gizmos
.ellipse(
Isometry3d::new(center, rotation * Quat::from_rotation_z(FRAC_PI_2)),
Vec2::new(radii.y, radii.z),
color,
)
.resolution(32);
}
fn draw_light(
gizmos: &mut Gizmos,
global: &GlobalTransform,