//! Editor-side scene visualizers for authoring/runtime entities that have no mesh. 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, RigidBodyDesc, SkinnedMeshRenderer, 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, EditorMode, PlayPossession}; use crate::viewport::collider_diagnostics::{ refresh_collider_diagnostics, ColliderDiagnosticEntry, ColliderDiagnosticsState, ColliderOverlayStatus, }; use crate::viewport::{EditorViewportMode, ViewportDisplayMode}; #[derive(Resource, Debug, Clone)] pub struct EditorVisualizationSettings { pub enabled: bool, pub show_actor_icons: bool, 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, pub show_actor_icon_prefab_model: bool, 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, } impl Default for EditorVisualizationSettings { fn default() -> Self { Self { enabled: true, show_actor_icons: true, 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, show_actor_icon_prefab_model: true, 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, } } } #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct EditorVisualizerProxy { pub target: Entity, pub kind: VisualizerKind, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub enum VisualizerKind { Collider, Light, PlayerSpawn, Prefab, Model, Player, Camera, ProjectSun, } #[derive(Resource)] struct VisualizerProxyAssets { mesh: Handle, material: Handle, } #[derive(SystemParam)] struct VisualizerTargetQueries<'w, 's> { transforms: Query<'w, 's, &'static GlobalTransform>, colliders: Query< 'w, 's, Entity, ( With, Or<(With, With, With)>, ), >, lights: Query<'w, 's, Entity, (With, With)>, spawns: Query<'w, 's, Entity, (With, With)>, prefabs: Query<'w, 's, Entity, (With, With)>, models: Query< 'w, 's, Entity, ( With, Or<(With, With)>, ), >, players: Query<'w, 's, Entity, With>, cameras: Query<'w, 's, Entity, With>, project_suns: Query<'w, 's, Entity, With>, } pub struct EditorVisualizersPlugin; impl Plugin for EditorVisualizersPlugin { fn build(&self, app: &mut App) { app.init_resource::() .init_resource::() .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, ( draw_visualizers, draw_audio_visualizers, draw_split_collider_visualizers, draw_missing_collider_visualizers, draw_post_process_volume_gizmos, draw_navigation_visualizers, ) .chain() .run_if(scene_tools_active) .run_if(viewport_editor_overlays_visible), ); } } fn draw_missing_collider_visualizers( viewport_mode: Res, settings: Res, diagnostics: Res, selected: Res, mut gizmos: Gizmos, missing: Query< (Entity, &GlobalTransform), ( With, With, Without, Without, ), >, ) { 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, mut gizmos: Gizmos, bounds: Query<(&NavigationBounds, &GlobalTransform), With>, obstacles: Query<(&NavigationObstacle, &GlobalTransform), With>, areas: Query<(&NavigationArea, &GlobalTransform), With>, links: Query<(&NavigationLink, &GlobalTransform), With>, ) { for (value, global) in &bounds { let half_extents = crate::ui::navigation_inspector::world_aabb_half_extents( global.affine(), value.half_extents, ); let center = global.translation(); draw_box( &mut gizmos, center, Quat::IDENTITY, half_extents, Color::srgba(0.12, 0.82, 0.78, 0.72), ); } for (value, global) in &obstacles { let half_extents = crate::ui::navigation_inspector::world_aabb_half_extents( global.affine(), value.half_extents, ); let center = global.translation(); draw_box( &mut gizmos, center, Quat::IDENTITY, half_extents, Color::srgba(1.0, 0.28, 0.22, 0.78), ); } for (value, global) in &areas { let half_extents = crate::ui::navigation_inspector::world_aabb_half_extents( global.affine(), value.half_extents, ); let center = global.translation(); let color = if value.walkable { Color::srgba(0.32, 0.72, 1.0, 0.62) } else { Color::srgba(1.0, 0.55, 0.18, 0.72) }; draw_box(&mut gizmos, center, Quat::IDENTITY, half_extents, color); } for (value, global) in &links { let start = global.transform_point(value.start); let end = global.transform_point(value.end); let color = if value.enabled { Color::srgba(0.95, 0.78, 0.22, 0.95) } else { Color::srgba(0.48, 0.48, 0.5, 0.55) }; gizmos.line(start, end, color); gizmos .sphere(Isometry3d::from_translation(start), 0.11, color) .resolution(12); gizmos .sphere(Isometry3d::from_translation(end), 0.11, color) .resolution(12); } if state.show_mesh { if let Some(artifact) = &state.artifact { for layer in &artifact.mesh.layers { for polygon in &layer.polygons { for index in 0..polygon.vertices.len() { let a_index = polygon.vertices[index] as usize; let b_index = polygon.vertices[(index + 1) % polygon.vertices.len()] as usize; let Some(a) = navigation_vertex(layer, a_index) else { continue; }; let Some(b) = navigation_vertex(layer, b_index) else { continue; }; gizmos.line( a + Vec3::Y * 0.025, b + Vec3::Y * 0.025, Color::srgba(0.08, 0.9, 0.72, 0.7), ); } } } } } for edge in state.preview_path.windows(2) { gizmos.line( edge[0] + Vec3::Y * 0.08, edge[1] + Vec3::Y * 0.08, Color::srgba(0.98, 0.88, 0.2, 1.0), ); } if let Some(start) = state.preview_path.first().copied() { gizmos .sphere( Isometry3d::from_translation(start + Vec3::Y * 0.08), 0.16, Color::srgba(0.2, 1.0, 0.55, 1.0), ) .resolution(14); } if let Some(end) = state.preview_path.last().copied() { gizmos .sphere( Isometry3d::from_translation(end + Vec3::Y * 0.08), 0.16, Color::srgba(1.0, 0.28, 0.22, 1.0), ) .resolution(14); } } fn navigation_vertex(layer: &polyanya::Layer, index: usize) -> Option { let vertex = layer.vertices.get(index)?; let height = layer.height.get(index).copied().unwrap_or_default(); let coords = vertex.coords + layer.offset; Some(Vec3::new(coords.x, height, coords.y)) } fn draw_audio_visualizers( viewport_mode: Res, settings: Res, selected: Res, mut gizmos: Gizmos, sources: Query<(Entity, &AudioSourceDesc, &GlobalTransform), With>, listeners: Query<(Entity, &AudioListenerDesc, &GlobalTransform), With>, ) { 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) -> bool { !display.clean_game_view } fn init_visualizer_proxy_assets( mut commands: Commands, mut meshes: ResMut>, mut materials: ResMut>, ) { commands.insert_resource(VisualizerProxyAssets { mesh: meshes.add(Sphere::new(0.22).mesh().uv(16, 8)), material: materials.add(StandardMaterial { base_color: Color::srgba(0.2, 0.8, 1.0, 0.08), alpha_mode: AlphaMode::Blend, unlit: true, ..default() }), }); } #[allow(clippy::too_many_arguments)] fn sync_visualizer_proxies( mode: Res>, possession: Res, viewport_mode: Res, display: Res, settings: Res, assets: Res, mut commands: Commands, mut proxies: Query<(Entity, &EditorVisualizerProxy, &mut Transform)>, targets: VisualizerTargetQueries, ) { let mut desired = std::collections::HashSet::new(); let collider_mode = *viewport_mode == EditorViewportMode::Collider; 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( targets .colliders .iter() .map(|target| (target, VisualizerKind::Collider)), ); } if settings.show_lights && !collider_mode { desired.extend( targets .lights .iter() .map(|target| (target, VisualizerKind::Light)), ); } if settings.show_spawns && !collider_mode { desired.extend( targets .spawns .iter() .map(|target| (target, VisualizerKind::PlayerSpawn)), ); } if settings.show_prefab_model_anchors && !collider_mode { desired.extend( targets .prefabs .iter() .map(|target| (target, VisualizerKind::Prefab)), ); desired.extend( targets .models .iter() .map(|target| (target, VisualizerKind::Model)), ); } if settings.show_runtime && !collider_mode { desired.extend( targets .players .iter() .map(|target| (target, VisualizerKind::Player)), ); desired.extend( targets .cameras .iter() .map(|target| (target, VisualizerKind::Camera)), ); desired.extend( targets .project_suns .iter() .map(|target| (target, VisualizerKind::ProjectSun)), ); } } let existing: std::collections::HashSet<(Entity, VisualizerKind)> = proxies .iter() .map(|(_, proxy, _)| (proxy.target, proxy.kind)) .collect(); for (entity, proxy, mut transform) in &mut proxies { if !desired.contains(&(proxy.target, proxy.kind)) || targets.transforms.get(proxy.target).is_err() { commands.entity(entity).despawn(); } else if let Ok(global) = targets.transforms.get(proxy.target) { transform.translation = global.translation(); } } for (target, kind) in desired { let Ok(global) = targets.transforms.get(target) else { continue; }; if existing.contains(&(target, kind)) { continue; } commands.spawn(( EditorOnly, RaytracingExcluded, Name::new(format!("{kind:?} Visualizer Proxy")), EditorVisualizerProxy { target, kind }, Mesh3d(assets.mesh.clone()), MeshMaterial3d(assets.material.clone()), Transform::from_translation(global.translation()), )); } } #[allow(clippy::too_many_arguments)] fn draw_visualizers( viewport_mode: Res, settings: Res, selected: Res, mut gizmos: Gizmos, colliders: Query<(Entity, &PhysicsBody, &GlobalTransform), With>, lights: Query<(Entity, &LightDesc, &GlobalTransform), With>, spawns: Query<(Entity, &GlobalTransform), (With, With)>, prefabs: Query<(Entity, &GlobalTransform), (With, With)>, models: Query< (Entity, &GlobalTransform), ( With, Or<(With, With)>, ), >, players: Query<(Entity, &GlobalTransform), With>, cameras: Query<(Entity, &GlobalTransform), With>, project_suns: Query<(Entity, &GlobalTransform), With>, triggers: Query<(Entity, &TriggerVolume, &GlobalTransform), With>, weapons: Query<(Entity, &GlobalTransform), (With, With)>, teams: Query<(Entity, &GlobalTransform), (With, With)>, objectives: Query<(Entity, &GlobalTransform), (With, With)>, ) { let collider_mode = *viewport_mode == EditorViewportMode::Collider; if !settings.enabled && !collider_mode { return; } if settings.show_colliders || collider_mode { for (entity, body, global) in &colliders { let color = collider_overlay_color(None, selected.0 == Some(entity), collider_mode); draw_collider(&mut gizmos, global, &body.collider, color); } } if settings.show_lights && !collider_mode { for (entity, light, global) in &lights { let color = if selected.0 == Some(entity) { Color::srgba(1.0, 0.9, 0.35, 1.0) } else { Color::srgba(1.0, 0.78, 0.25, 0.75) }; draw_light(&mut gizmos, global, light, color, true); } } if settings.show_spawns { for (entity, global) in &spawns { let color = if selected.0 == Some(entity) { Color::srgba(0.2, 1.0, 1.0, 1.0) } else { Color::srgba(0.15, 0.85, 1.0, 0.75) }; draw_spawn(&mut gizmos, global, color); } } if settings.show_prefab_model_anchors { for (entity, global) in &prefabs { draw_anchor( &mut gizmos, global, selected.0 == Some(entity), Color::srgb(0.75, 0.45, 1.0), ); } for (entity, global) in &models { draw_anchor( &mut gizmos, global, selected.0 == Some(entity), Color::srgb(0.5, 0.6, 1.0), ); } } if settings.show_runtime { for (entity, global) in &players { let color = if selected.0 == Some(entity) { Color::srgba(0.25, 0.65, 1.0, 1.0) } else { Color::srgba(0.25, 0.65, 1.0, 0.7) }; draw_player(&mut gizmos, global, color); } for (entity, global) in &cameras { let color = if selected.0 == Some(entity) { Color::srgba(0.4, 0.85, 1.0, 1.0) } else { Color::srgba(0.4, 0.85, 1.0, 0.7) }; draw_camera_frustum(&mut gizmos, global, color); } for (entity, global) in &project_suns { let color = if selected.0 == Some(entity) { Color::srgba(1.0, 0.88, 0.32, 1.0) } else { Color::srgba(1.0, 0.78, 0.18, 0.75) }; draw_project_sun(&mut gizmos, global, color, true); } } 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), ); } } } #[expect( clippy::too_many_arguments, reason = "collider overlays combine authoring, runtime bounds, selection, and viewport state" )] fn draw_split_collider_visualizers( viewport_mode: Res, settings: Res, diagnostics: Res, selected: Res, mut gizmos: Gizmos, children: Query<&Children>, runtime_aabbs: Query<&ColliderAabb>, colliders: Query< (Entity, &ColliderDesc, &GlobalTransform), (With, Without), >, ) { let collider_mode = *viewport_mode == EditorViewportMode::Collider; if !settings.enabled && !collider_mode { return; } if !(settings.show_colliders || collider_mode) { return; } for (entity, collider, global) in &colliders { 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, settings: Res, selected: Res, mut gizmos: Gizmos, volumes: Query<(Entity, &PostProcessVolumeDesc, &GlobalTransform), With>, ) { if *viewport_mode == EditorViewportMode::Collider || !settings.enabled || !settings.show_volumes { return; } for (entity, volume, global) in &volumes { let t = ((volume.priority + 10) as f32 / 110.0).clamp(0.0, 1.0); let border = Color::srgba(0.2 + 0.8 * t, 0.45 + 0.2 * (1.0 - t), 1.0 - 0.65 * t, 0.95); draw_oriented_box( &mut gizmos, global, volume.half_extents, if selected.0 == Some(entity) { Color::srgba(1.0, 0.76, 0.34, 1.0) } else { border.with_alpha(0.55) }, ); } } fn draw_collider( gizmos: &mut Gizmos, global: &GlobalTransform, collider: &ColliderConstructor, color: Color, ) { let (scale, rotation, translation) = global.to_scale_rotation_translation(); let scale = scale.abs(); match collider { ColliderConstructor::Cuboid { x_length, y_length, z_length, } => draw_box( gizmos, translation, rotation, Vec3::new(*x_length, *y_length, *z_length) * scale * 0.5, color, ), ColliderConstructor::Sphere { radius } => { draw_ellipsoid(gizmos, translation, rotation, scale * *radius, color); } ColliderConstructor::Capsule { radius, height } => { draw_capsule( gizmos, translation, rotation, *radius * scale.x.max(scale.z), *height * scale.y, color, ); } _ => { gizmos .sphere( Isometry3d::new(global.translation(), global.rotation()), 0.5, color, ) .resolution(16); } } } fn draw_collider_desc( gizmos: &mut Gizmos, global: &GlobalTransform, collider: &ColliderDesc, color: Color, ) { let (scale, rotation, translation) = global.to_scale_rotation_translation(); let scale = scale.abs(); match &collider.shape { ColliderShapeDesc::Cuboid { x_length, y_length, z_length, } => draw_box( gizmos, translation, rotation, Vec3::new(*x_length, *y_length, *z_length) * scale * 0.5, color, ), ColliderShapeDesc::Sphere { radius } => { draw_ellipsoid(gizmos, translation, rotation, scale * *radius, color); } ColliderShapeDesc::Capsule { radius, height } => { draw_capsule( gizmos, translation, rotation, *radius * scale.x.max(scale.z), *height * scale.y, color, ); } ColliderShapeDesc::StaticMesh { .. } => { 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, light: &LightDesc, color: Color, emphasize: bool, ) { let center = global.translation(); let forward = global.forward().as_vec3(); match light.kind { AuthoringLightKind::Point => { let radius = light.range.max(0.25); gizmos .sphere(Isometry3d::new(center, global.rotation()), radius, color) .resolution(32); if emphasize { gizmos .circle( Isometry3d::from_translation(center), radius, color.with_alpha(0.45), ) .resolution(32); } } AuthoringLightKind::Spot => { let range = light.range.max(1.0); let end = center + forward * range; gizmos.arrow(center, end, color); let right = global.right().as_vec3(); 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( Isometry3d::new(end, global.rotation()), radius * 0.12, color.with_alpha(0.5), ) .resolution(12); } } AuthoringLightKind::Directional => { draw_directional_light_arrow(gizmos, global, color); } } } fn draw_directional_light_arrow(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color) { let center = global.translation(); let forward = global.forward().as_vec3(); let arrow_len = 5.0; let tail = center - forward * arrow_len; gizmos.arrow(tail, center, color); gizmos .sphere(Isometry3d::new(center, global.rotation()), 0.4, color) .resolution(18); let right = global.right().as_vec3(); let up = global.up().as_vec3(); for offset in [right, -right, up, -up] { gizmos.line(center, center + offset * 0.75, color.with_alpha(0.65)); } } fn draw_spawn(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color) { let center = global.translation(); draw_capsule( gizmos, center, global.rotation(), PLAYER_RADIUS, PLAYER_LENGTH, color, ); gizmos.arrow(center, center + global.forward().as_vec3() * 1.25, color); gizmos .sphere( Isometry3d::new(center + Vec3::Y * EYE_OFFSET_STAND, global.rotation()), 0.08, color, ) .resolution(10); } 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.76, 0.34, 1.0) } else { base.with_alpha(0.75) }; gizmos.axes(Isometry3d::new(center, global.rotation()), 0.8); draw_box(gizmos, center, global.rotation(), Vec3::splat(0.35), color); } fn draw_player(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color) { let center = global.translation(); draw_capsule( gizmos, center, global.rotation(), PLAYER_RADIUS, PLAYER_LENGTH, color, ); gizmos.arrow(center, center + global.forward().as_vec3() * 1.25, color); gizmos .sphere( Isometry3d::new(center + Vec3::Y * EYE_OFFSET_STAND, global.rotation()), 0.08, color, ) .resolution(10); } fn draw_project_sun(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color, emphasize: bool) { let center = global.translation(); gizmos .sphere(Isometry3d::new(center, global.rotation()), 0.45, color) .resolution(20); draw_directional_light_arrow(gizmos, global, color); if emphasize { gizmos .circle( Isometry3d::new(center, global.rotation()), 1.0, color.with_alpha(0.35), ) .resolution(28); } else { gizmos .circle(Isometry3d::new(center, global.rotation()), 0.75, color) .resolution(24); } } fn draw_camera_frustum(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color) { let origin = global.translation(); let forward = global.forward().as_vec3(); let right = global.right().as_vec3(); let up = global.up().as_vec3(); 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(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) { let corners = [ Vec3::new(-half.x, -half.y, -half.z), Vec3::new(half.x, -half.y, -half.z), Vec3::new(half.x, -half.y, half.z), Vec3::new(-half.x, -half.y, half.z), Vec3::new(-half.x, half.y, -half.z), Vec3::new(half.x, half.y, -half.z), Vec3::new(half.x, half.y, half.z), Vec3::new(-half.x, half.y, half.z), ] .map(|corner| center + rotation * corner); for (a, b) in [ (0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 7), (7, 4), (0, 4), (1, 5), (2, 6), (3, 7), ] { gizmos.line(corners[a], corners[b], color); } } fn draw_capsule( gizmos: &mut Gizmos, center: Vec3, rotation: Quat, radius: f32, length: f32, color: Color, ) { let half = length * 0.5; let top = center + rotation * Vec3::Y * half; let bottom = center - rotation * Vec3::Y * half; gizmos .sphere(Isometry3d::new(top, rotation), radius, color) .resolution(16); gizmos .sphere(Isometry3d::new(bottom, rotation), radius, color) .resolution(16); for (x, z) in [(radius, 0.0), (-radius, 0.0), (0.0, radius), (0.0, -radius)] { let offset = rotation * Vec3::new(x, 0.0, z); gizmos.line(top + offset, bottom + offset, color); } } fn draw_oriented_box( gizmos: &mut Gizmos, global: &GlobalTransform, half_extents: Vec3, color: Color, ) { let rotation = global.rotation(); let center = global.translation(); let corners = box_corners(center, rotation, half_extents); for (a, b) in box_edges() { gizmos.line(corners[a], corners[b], color); } } fn box_corners(center: Vec3, rotation: Quat, half_extents: Vec3) -> [Vec3; 8] { let hx = half_extents.x; let hy = half_extents.y; let hz = half_extents.z; [ center + rotation * Vec3::new(-hx, -hy, -hz), center + rotation * Vec3::new(hx, -hy, -hz), center + rotation * Vec3::new(hx, -hy, hz), center + rotation * Vec3::new(-hx, -hy, hz), center + rotation * Vec3::new(-hx, hy, -hz), center + rotation * Vec3::new(hx, hy, -hz), center + rotation * Vec3::new(hx, hy, hz), center + rotation * Vec3::new(-hx, hy, hz), ] } fn box_edges() -> [(usize, usize); 12] { [ (0, 1), (1, 2), (2, 3), (3, 0), (4, 5), (5, 6), (6, 7), (7, 4), (0, 4), (1, 5), (2, 6), (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); } }