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

1288 lines
40 KiB
Rust

//! 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<Mesh>,
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>, With<RigidBodyDesc>)>,
),
>,
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>,
Or<(With<ModelRef>, With<SkinnedMeshRenderer>)>,
),
>,
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>()
.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,
(
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<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,
bounds: Query<(&NavigationBounds, &GlobalTransform), With<LevelObject>>,
obstacles: Query<(&NavigationObstacle, &GlobalTransform), With<LevelObject>>,
areas: Query<(&NavigationArea, &GlobalTransform), With<LevelObject>>,
links: Query<(&NavigationLink, &GlobalTransform), With<LevelObject>>,
) {
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<Vec3> {
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<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
}
fn init_visualizer_proxy_assets(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
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<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)>,
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<EditorViewportMode>,
settings: Res<EditorVisualizationSettings>,
selected: Res<SelectedEntity>,
mut gizmos: Gizmos,
colliders: Query<(Entity, &PhysicsBody, &GlobalTransform), With<LevelObject>>,
lights: Query<(Entity, &LightDesc, &GlobalTransform), With<LevelObject>>,
spawns: Query<(Entity, &GlobalTransform), (With<LevelObject>, With<PlayerSpawn>)>,
prefabs: Query<(Entity, &GlobalTransform), (With<LevelObject>, With<PrefabRef>)>,
models: Query<
(Entity, &GlobalTransform),
(
With<LevelObject>,
Or<(With<ModelRef>, With<SkinnedMeshRenderer>)>,
),
>,
players: Query<(Entity, &GlobalTransform), With<Player>>,
cameras: Query<(Entity, &GlobalTransform), With<PlayerCamera>>,
project_suns: Query<(Entity, &GlobalTransform), With<ProjectSun>>,
triggers: Query<(Entity, &TriggerVolume, &GlobalTransform), With<LevelObject>>,
weapons: Query<(Entity, &GlobalTransform), (With<LevelObject>, With<WeaponSpawn>)>,
teams: Query<(Entity, &GlobalTransform), (With<LevelObject>, With<TeamSpawn>)>,
objectives: Query<(Entity, &GlobalTransform), (With<LevelObject>, With<ObjectiveMarker>)>,
) {
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<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>),
>,
) {
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<EditorViewportMode>,
settings: Res<EditorVisualizationSettings>,
selected: Res<SelectedEntity>,
mut gizmos: Gizmos,
volumes: Query<(Entity, &PostProcessVolumeDesc, &GlobalTransform), With<LevelObject>>,
) {
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);
}
}