Build production-ready editor authoring workflows
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-07-11 12:41:04 -04:00
1 parent cc1fa6ea3b
commit 0553a85220
163 files changed
+34547 -1565

No files matched your search

+295 -82
View File
@@ -1,18 +1,20 @@
//! Editor-side scene visualizers for authoring/runtime entities that have no mesh.
use avian3d::prelude::ColliderConstructor;
use bevy::ecs::system::SystemParam;
use bevy::prelude::*;
use shared::{
AuthoringLightKind, ColliderDesc, ColliderShapeDesc, LevelObject, LightDesc, ModelRef,
ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabRef, ProjectSun,
RaytracingExcluded, TeamSpawn, TriggerVolume, WeaponSpawn,
AudioListenerDesc, AudioSourceDesc, AuthoringLightKind, ColliderDesc, ColliderShapeDesc,
LevelObject, LightDesc, ModelRef, ObjectiveMarker, PhysicsBody, PlayerSpawn,
PostProcessVolumeDesc, PrefabRef, ProjectSun, RaytracingExcluded, TeamSpawn, TriggerVolume,
WeaponSpawn,
};
use sim::tuning::{EYE_OFFSET_STAND, PLAYER_LENGTH, PLAYER_RADIUS};
use sim::{Player, PlayerCamera};
use crate::infra::EditorOnly;
use crate::selection::SelectedEntity;
use crate::state::scene_tools_active;
use crate::state::{scene_tools_active, EditorMode, PlayPossession};
use crate::viewport::{EditorViewportMode, ViewportDisplayMode};
#[derive(Resource, Debug, Clone)]
@@ -22,6 +24,7 @@ pub struct EditorVisualizationSettings {
pub show_actor_icon_actor: bool,
pub show_actor_icon_mesh: bool,
pub show_actor_icon_light: bool,
pub show_actor_icon_audio: bool,
pub show_actor_icon_physics: bool,
pub show_actor_icon_gameplay: bool,
pub show_actor_icon_volume: bool,
@@ -29,7 +32,10 @@ pub struct EditorVisualizationSettings {
pub show_actor_icon_debug: bool,
pub show_colliders: bool,
pub show_lights: bool,
pub show_audio: bool,
pub show_spawns: bool,
pub show_gameplay: bool,
pub show_volumes: bool,
pub show_prefab_model_anchors: bool,
pub show_runtime: bool,
pub pickable_proxies: bool,
@@ -43,6 +49,7 @@ impl Default for EditorVisualizationSettings {
show_actor_icon_actor: true,
show_actor_icon_mesh: true,
show_actor_icon_light: true,
show_actor_icon_audio: true,
show_actor_icon_physics: true,
show_actor_icon_gameplay: true,
show_actor_icon_volume: true,
@@ -50,7 +57,10 @@ impl Default for EditorVisualizationSettings {
show_actor_icon_debug: true,
show_colliders: true,
show_lights: true,
show_audio: true,
show_spawns: true,
show_gameplay: true,
show_volumes: true,
show_prefab_model_anchors: true,
show_runtime: true,
pickable_proxies: true,
@@ -82,17 +92,39 @@ struct VisualizerProxyAssets {
material: Handle<StandardMaterial>,
}
#[derive(SystemParam)]
struct VisualizerTargetQueries<'w, 's> {
transforms: Query<'w, 's, &'static GlobalTransform>,
colliders: Query<
'w,
's,
Entity,
(
With<LevelObject>,
Or<(With<PhysicsBody>, With<ColliderDesc>)>,
),
>,
lights: Query<'w, 's, Entity, (With<LevelObject>, With<LightDesc>)>,
spawns: Query<'w, 's, Entity, (With<LevelObject>, With<PlayerSpawn>)>,
prefabs: Query<'w, 's, Entity, (With<LevelObject>, With<PrefabRef>)>,
models: Query<'w, 's, Entity, (With<LevelObject>, With<ModelRef>)>,
players: Query<'w, 's, Entity, With<Player>>,
cameras: Query<'w, 's, Entity, With<PlayerCamera>>,
project_suns: Query<'w, 's, Entity, With<ProjectSun>>,
}
pub struct EditorVisualizersPlugin;
impl Plugin for EditorVisualizersPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<EditorVisualizationSettings>()
.add_systems(Startup, init_visualizer_proxy_assets)
.add_systems(Update, sync_visualizer_proxies.run_if(scene_tools_active))
.add_systems(Update, sync_visualizer_proxies)
.add_systems(
Update,
(
draw_visualizers,
draw_audio_visualizers,
draw_split_collider_visualizers,
draw_post_process_volume_gizmos,
)
@@ -103,6 +135,124 @@ impl Plugin for EditorVisualizersPlugin {
}
}
fn draw_audio_visualizers(
viewport_mode: Res<EditorViewportMode>,
settings: Res<EditorVisualizationSettings>,
selected: Res<SelectedEntity>,
mut gizmos: Gizmos,
sources: Query<(Entity, &AudioSourceDesc, &GlobalTransform), With<LevelObject>>,
listeners: Query<(Entity, &AudioListenerDesc, &GlobalTransform), With<LevelObject>>,
) {
if *viewport_mode == EditorViewportMode::Collider || !settings.enabled || !settings.show_audio {
return;
}
let Some(selected) = selected.0 else {
return;
};
if let Ok((_, source, global)) = sources.get(selected) {
draw_audio_source(&mut gizmos, global, source);
}
if let Ok((_, listener, global)) = listeners.get(selected) {
draw_audio_listener(&mut gizmos, global, listener);
}
}
fn draw_audio_source(gizmos: &mut Gizmos, global: &GlobalTransform, source: &AudioSourceDesc) {
let center = global.translation();
let (min_distance, max_distance) = normalized_audio_radii(
source.attenuation.min_distance,
source.attenuation.max_distance,
);
let blend = source.spatial_blend.clamp(0.0, 1.0);
let inner = Color::srgba(0.28, 0.92, 1.0, 0.9);
let outer = Color::srgba(0.22, 0.68, 1.0, 0.28 + blend * 0.32);
gizmos
.sphere(
Isometry3d::new(center, global.rotation()),
min_distance,
inner,
)
.resolution(28);
gizmos
.sphere(
Isometry3d::new(center, global.rotation()),
max_distance,
outer,
)
.resolution(36);
}
fn draw_audio_listener(
gizmos: &mut Gizmos,
global: &GlobalTransform,
listener: &AudioListenerDesc,
) {
let geometry =
audio_listener_geometry(global.translation(), global.rotation(), listener.ear_gap);
let color = if listener.enabled {
Color::srgba(0.35, 1.0, 0.76, 1.0)
} else {
Color::srgba(0.55, 0.62, 0.66, 0.75)
};
gizmos.line(geometry.left_ear, geometry.right_ear, color);
for ear in [geometry.left_ear, geometry.right_ear] {
gizmos
.sphere(Isometry3d::from_translation(ear), 0.07, color)
.resolution(12);
}
gizmos.arrow(geometry.center, geometry.forward_end, color);
gizmos
.circle(
Isometry3d::new(geometry.center, global.rotation()),
geometry.head_radius,
color.with_alpha(0.55),
)
.resolution(24);
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct AudioListenerGeometry {
center: Vec3,
left_ear: Vec3,
right_ear: Vec3,
forward_end: Vec3,
head_radius: f32,
}
fn normalized_audio_radii(min_distance: f32, max_distance: f32) -> (f32, f32) {
let min_distance = if min_distance.is_finite() {
min_distance.max(0.05)
} else {
0.05
};
let max_distance = if max_distance.is_finite() {
max_distance.max(min_distance)
} else {
min_distance
};
(min_distance, max_distance)
}
fn audio_listener_geometry(center: Vec3, rotation: Quat, ear_gap: f32) -> AudioListenerGeometry {
let ear_gap = if ear_gap.is_finite() {
ear_gap.max(0.02)
} else {
0.02
};
let right = rotation * Vec3::X;
let forward = rotation * Vec3::NEG_Z;
AudioListenerGeometry {
center,
left_ear: center - right * ear_gap * 0.5,
right_ear: center + right * ear_gap * 0.5,
forward_end: center + forward * 0.85,
head_radius: (ear_gap * 0.65).max(0.14),
}
}
fn viewport_editor_overlays_visible(display: Res<ViewportDisplayMode>) -> bool {
!display.clean_game_view
}
@@ -125,73 +275,80 @@ fn init_visualizer_proxy_assets(
#[allow(clippy::too_many_arguments)]
fn sync_visualizer_proxies(
mode: Res<State<EditorMode>>,
possession: Res<PlayPossession>,
viewport_mode: Res<EditorViewportMode>,
display: Res<ViewportDisplayMode>,
settings: Res<EditorVisualizationSettings>,
assets: Res<VisualizerProxyAssets>,
mut commands: Commands,
mut proxies: Query<(Entity, &EditorVisualizerProxy, &mut Transform)>,
transforms: Query<&GlobalTransform>,
colliders: Query<
Entity,
(
With<LevelObject>,
Or<(With<PhysicsBody>, With<ColliderDesc>)>,
),
>,
lights: Query<Entity, (With<LevelObject>, With<LightDesc>)>,
spawns: Query<Entity, (With<LevelObject>, With<PlayerSpawn>)>,
prefabs: Query<Entity, (With<LevelObject>, With<PrefabRef>)>,
models: Query<Entity, (With<LevelObject>, With<ModelRef>)>,
players: Query<Entity, With<Player>>,
cameras: Query<Entity, With<PlayerCamera>>,
project_suns: Query<Entity, With<ProjectSun>>,
targets: VisualizerTargetQueries,
) {
let mut desired = std::collections::HashSet::new();
let collider_mode = *viewport_mode == EditorViewportMode::Collider;
let proxies_active = !display.clean_game_view
let tools_active = *mode.get() == EditorMode::Editing
|| (*mode.get() == EditorMode::Playing && *possession == PlayPossession::Ejected);
let proxies_active = tools_active
&& !display.clean_game_view
&& settings.enabled
&& (settings.pickable_proxies || collider_mode);
if proxies_active {
if settings.show_colliders || collider_mode {
desired.extend(
colliders
targets
.colliders
.iter()
.map(|target| (target, VisualizerKind::Collider)),
);
}
if settings.show_lights && !collider_mode {
desired.extend(lights.iter().map(|target| (target, VisualizerKind::Light)));
desired.extend(
targets
.lights
.iter()
.map(|target| (target, VisualizerKind::Light)),
);
}
if settings.show_spawns && !collider_mode {
desired.extend(
spawns
targets
.spawns
.iter()
.map(|target| (target, VisualizerKind::PlayerSpawn)),
);
}
if settings.show_prefab_model_anchors && !collider_mode {
desired.extend(
prefabs
targets
.prefabs
.iter()
.map(|target| (target, VisualizerKind::Prefab)),
);
desired.extend(models.iter().map(|target| (target, VisualizerKind::Model)));
desired.extend(
targets
.models
.iter()
.map(|target| (target, VisualizerKind::Model)),
);
}
if settings.show_runtime && !collider_mode {
desired.extend(
players
targets
.players
.iter()
.map(|target| (target, VisualizerKind::Player)),
);
desired.extend(
cameras
targets
.cameras
.iter()
.map(|target| (target, VisualizerKind::Camera)),
);
desired.extend(
project_suns
targets
.project_suns
.iter()
.map(|target| (target, VisualizerKind::ProjectSun)),
);
@@ -204,15 +361,17 @@ fn sync_visualizer_proxies(
.collect();
for (entity, proxy, mut transform) in &mut proxies {
if !desired.contains(&(proxy.target, proxy.kind)) || transforms.get(proxy.target).is_err() {
if !desired.contains(&(proxy.target, proxy.kind))
|| targets.transforms.get(proxy.target).is_err()
{
commands.entity(entity).despawn();
} else if let Ok(global) = transforms.get(proxy.target) {
} else if let Ok(global) = targets.transforms.get(proxy.target) {
transform.translation = global.translation();
}
}
for (target, kind) in desired {
let Ok(global) = transforms.get(target) else {
let Ok(global) = targets.transforms.get(target) else {
continue;
};
if existing.contains(&(target, kind)) {
@@ -339,41 +498,43 @@ fn draw_visualizers(
}
}
for (entity, trigger, global) in &triggers {
draw_oriented_box(
&mut gizmos,
global,
trigger.half_extents,
if selected.0 == Some(entity) {
Color::srgba(0.95, 0.35, 0.95, 0.85)
} else {
Color::srgba(0.9, 0.3, 0.9, 0.45)
},
);
}
for (entity, global) in &weapons {
draw_anchor(
&mut gizmos,
global,
selected.0 == Some(entity),
Color::srgb(1.0, 0.35, 0.2),
);
}
for (entity, global) in &teams {
draw_anchor(
&mut gizmos,
global,
selected.0 == Some(entity),
Color::srgb(0.2, 0.85, 0.35),
);
}
for (entity, global) in &objectives {
draw_anchor(
&mut gizmos,
global,
selected.0 == Some(entity),
Color::srgb(0.95, 0.85, 0.2),
);
if settings.show_gameplay && !collider_mode {
for (entity, trigger, global) in &triggers {
draw_oriented_box(
&mut gizmos,
global,
trigger.half_extents,
if selected.0 == Some(entity) {
Color::srgba(1.0, 0.55, 0.95, 0.95)
} else {
Color::srgba(0.9, 0.3, 0.9, 0.42)
},
);
}
for (entity, global) in &weapons {
draw_anchor(
&mut gizmos,
global,
selected.0 == Some(entity),
Color::srgb(1.0, 0.35, 0.2),
);
}
for (entity, global) in &teams {
draw_anchor(
&mut gizmos,
global,
selected.0 == Some(entity),
Color::srgb(0.2, 0.85, 0.35),
);
}
for (entity, global) in &objectives {
draw_anchor(
&mut gizmos,
global,
selected.0 == Some(entity),
Color::srgb(0.95, 0.85, 0.2),
);
}
}
}
@@ -413,7 +574,8 @@ fn draw_post_process_volume_gizmos(
mut gizmos: Gizmos,
volumes: Query<(Entity, &PostProcessVolumeDesc, &GlobalTransform), With<LevelObject>>,
) {
if *viewport_mode == EditorViewportMode::Collider || !settings.enabled {
if *viewport_mode == EditorViewportMode::Collider || !settings.enabled || !settings.show_volumes
{
return;
}
for (entity, volume, global) in &volumes {
@@ -424,7 +586,7 @@ fn draw_post_process_volume_gizmos(
global,
volume.half_extents,
if selected.0 == Some(entity) {
border.with_alpha(1.0)
Color::srgba(1.0, 0.76, 0.34, 1.0)
} else {
border.with_alpha(0.55)
},
@@ -566,12 +728,20 @@ fn draw_light(
let up = global.up().as_vec3();
let outer_deg = light.outer_angle_deg.max(light.inner_angle_deg);
let radius = range * (outer_deg.to_radians() * 0.5).tan().max(0.15);
let inner_radius = range * (light.inner_angle_deg.to_radians() * 0.5).tan().max(0.08);
for offset in [right, -right, up, -up] {
gizmos.line(center, end + offset * radius, color);
}
gizmos
.circle(Isometry3d::new(end, global.rotation()), radius, color)
.resolution(24);
gizmos
.circle(
Isometry3d::new(end, global.rotation()),
inner_radius,
color.with_alpha(0.38),
)
.resolution(24);
if emphasize {
gizmos
.sphere(
@@ -627,7 +797,7 @@ fn draw_spawn(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color) {
fn draw_anchor(gizmos: &mut Gizmos, global: &GlobalTransform, selected: bool, base: Color) {
let center = global.translation();
let color = if selected {
Color::srgba(1.0, 0.85, 1.0, 1.0)
Color::srgba(1.0, 0.76, 0.34, 1.0)
} else {
base.with_alpha(0.75)
};
@@ -681,19 +851,34 @@ fn draw_camera_frustum(gizmos: &mut Gizmos, global: &GlobalTransform, color: Col
let forward = global.forward().as_vec3();
let right = global.right().as_vec3();
let up = global.up().as_vec3();
let near = origin + forward * 0.8;
let half_w = 0.45;
let half_h = 0.28;
let corners = [
near + right * half_w + up * half_h,
near - right * half_w + up * half_h,
near - right * half_w - up * half_h,
near + right * half_w - up * half_h,
];
for corner in corners {
gizmos.line(origin, corner, color);
let near_center = origin + forward * 0.55;
let far_center = origin + forward * 2.4;
let near = frustum_corners(near_center, right, up, 0.28, 0.17);
let far = frustum_corners(far_center, right, up, 1.1, 0.66);
for corner in near {
gizmos.line(origin, corner, color.with_alpha(0.72));
}
gizmos.lineloop(corners, color);
gizmos.lineloop(near, color.with_alpha(0.72));
gizmos.lineloop(far, color);
for index in 0..4 {
gizmos.line(near[index], far[index], color);
}
gizmos.arrow(origin, origin + forward * 1.15, color.with_alpha(0.8));
}
fn frustum_corners(
center: Vec3,
right: Vec3,
up: Vec3,
half_width: f32,
half_height: f32,
) -> [Vec3; 4] {
[
center + right * half_width + up * half_height,
center - right * half_width + up * half_height,
center - right * half_width - up * half_height,
center + right * half_width - up * half_height,
]
}
fn draw_box(gizmos: &mut Gizmos, center: Vec3, rotation: Quat, half: Vec3, color: Color) {
@@ -798,3 +983,31 @@ fn box_edges() -> [(usize, usize); 12] {
(3, 7),
]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn audio_radii_are_finite_positive_and_ordered() {
assert_eq!(normalized_audio_radii(2.0, 8.0), (2.0, 8.0));
assert_eq!(normalized_audio_radii(4.0, 1.0), (4.0, 4.0));
assert_eq!(
normalized_audio_radii(f32::NAN, f32::INFINITY),
(0.05, 0.05)
);
}
#[test]
fn listener_geometry_respects_rotation_and_ear_gap() {
let geometry = audio_listener_geometry(
Vec3::new(2.0, 3.0, 4.0),
Quat::from_rotation_y(std::f32::consts::FRAC_PI_2),
0.4,
);
assert!((geometry.left_ear.distance(geometry.right_ear) - 0.4).abs() < 1.0e-5);
assert!((geometry.forward_end - Vec3::new(1.15, 3.0, 4.0)).length() < 1.0e-5);
assert!(geometry.head_radius >= 0.14);
}
}