This commit is contained in:
1 parent
0e7aed40f1
commit
0ce43fc399
19 files changed
+1180
-127
No files matched your search
@@ -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;
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
|
||||
@@ -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,
|
||||
|
||||
Reference in new issue
Block a user