657 lines
24 KiB
Rust
657 lines
24 KiB
Rust
//! Selectable editor-only billboards at actor roots.
|
|
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
use bevy::asset::{load_internal_binary_asset, uuid_handle, RenderAssetUsages};
|
|
use bevy::camera::visibility::NoFrustumCulling;
|
|
use bevy::image::{CompressedImageFormats, ImageSampler, ImageType};
|
|
use bevy::prelude::*;
|
|
use shared::{
|
|
ActorKind, AuthoringLightKind, ColliderDesc, LevelObject, LightDesc, ModelRef, ObjectiveMarker,
|
|
PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabInstance, PrefabRef, Primitive,
|
|
RaytracingExcluded, StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
|
|
};
|
|
|
|
use crate::camera::EditorCamera;
|
|
use crate::infra::EditorOnly;
|
|
use crate::state::scene_tools_active;
|
|
use crate::ui::UiState;
|
|
use crate::viewport::ViewportDisplayMode;
|
|
use crate::visualizers::EditorVisualizationSettings;
|
|
|
|
const ICON_TARGET_PIXELS: f32 = 30.0;
|
|
const ICON_MIN_WORLD_SIZE: f32 = 0.2;
|
|
const ICON_MAX_WORLD_SIZE: f32 = 3.0;
|
|
const DEFAULT_PERSPECTIVE_FOV: f32 = std::f32::consts::FRAC_PI_4;
|
|
|
|
const ICON_01_ACTOR_EMPTY: Handle<Image> = uuid_handle!("d87c7796-b219-4011-8305-4db55422f1c7");
|
|
const ICON_02_ACTOR_GENERIC: Handle<Image> = uuid_handle!("c9a1a84f-4dcd-4a2b-a5b6-c365dc7d6795");
|
|
const ICON_03_ACTOR_MISSING: Handle<Image> = uuid_handle!("cca7cdf9-0c7d-4546-9bb9-1176e49a635c");
|
|
const ICON_04_ACTOR_WARNING: Handle<Image> = uuid_handle!("7dba1d9c-0569-40d2-978e-66014377051d");
|
|
const ICON_05_RENDER_MESH: Handle<Image> = uuid_handle!("10c70a1d-3327-458a-92d2-db41f893432e");
|
|
const ICON_06_RENDER_DECAL: Handle<Image> = uuid_handle!("8c27ff62-0d94-4184-81cf-977e652a0496");
|
|
const ICON_07_RENDER_PARTICLE: Handle<Image> = uuid_handle!("0db519d6-0eca-4389-9393-2e0c38f73119");
|
|
const ICON_08_RENDER_BILLBOARD: Handle<Image> =
|
|
uuid_handle!("2fcb8e83-8f51-4978-8b29-146e2c44b5e6");
|
|
const ICON_09_LIGHT_POINT: Handle<Image> = uuid_handle!("ba2cbf62-c547-4cfe-ba61-4081076da93b");
|
|
const ICON_10_LIGHT_SPOT: Handle<Image> = uuid_handle!("200ee881-9cac-41d1-89be-45581642968f");
|
|
const ICON_11_LIGHT_DIRECTIONAL: Handle<Image> =
|
|
uuid_handle!("d9de4730-2463-41dc-87e9-ed99b013d74a");
|
|
const ICON_12_LIGHT_AREA: Handle<Image> = uuid_handle!("d43ea6a8-15da-4792-8d63-962211f94ad6");
|
|
const ICON_13_CAMERA_MAIN: Handle<Image> = uuid_handle!("1979cc52-7285-4bb3-88f5-bd82021c10fa");
|
|
const ICON_14_CAMERA_CAPTURE: Handle<Image> = uuid_handle!("f1fc47d3-eaf4-4aaf-becc-b51a64f0b070");
|
|
const ICON_15_AUDIO_SOURCE: Handle<Image> = uuid_handle!("2dd3091f-2dea-4626-8430-79fa44a53c68");
|
|
const ICON_16_AUDIO_LISTENER: Handle<Image> = uuid_handle!("9eb3177f-e3d5-45cb-bd7c-49eecb4eb8e3");
|
|
const ICON_17_PHYSICS_COLLIDER: Handle<Image> =
|
|
uuid_handle!("69f02ada-e171-484b-9a46-af753971e9c1");
|
|
const ICON_18_PHYSICS_RIGIDBODY: Handle<Image> =
|
|
uuid_handle!("c30ddfb8-a851-45ab-98a9-97add45f1b49");
|
|
const ICON_19_PHYSICS_TRIGGER: Handle<Image> = uuid_handle!("3cf22740-463a-41b0-a1d7-d0cccc910b70");
|
|
const ICON_20_PHYSICS_JOINT: Handle<Image> = uuid_handle!("cdb8ef15-d41c-4f34-bc98-4a61f4628508");
|
|
const ICON_21_GAME_SPAWN: Handle<Image> = uuid_handle!("56719033-f1db-4749-8637-9b004581ce81");
|
|
const ICON_22_GAME_TRIGGER: Handle<Image> = uuid_handle!("98e42034-1c34-40af-8955-12c12cc2e261");
|
|
const ICON_23_GAME_MARKER: Handle<Image> = uuid_handle!("7808784d-c117-41a9-84db-fae5d4edbf3a");
|
|
const ICON_24_GAME_INTERACTABLE: Handle<Image> =
|
|
uuid_handle!("e61fc53a-5201-49a4-9451-88d7c804a5c5");
|
|
const ICON_25_NAV_WAYPOINT: Handle<Image> = uuid_handle!("26511234-47bc-4cdc-b24c-39bfec7e46da");
|
|
const ICON_26_NAV_LINK: Handle<Image> = uuid_handle!("6f4988e9-b571-45af-a3ad-777d80a3d9b6");
|
|
const ICON_27_NAV_REGION: Handle<Image> = uuid_handle!("02b7ae0d-b3d6-4e46-8be0-8ee590ea71cc");
|
|
const ICON_28_VOLUME_GENERIC: Handle<Image> = uuid_handle!("670cf8ce-c33e-4f86-ae7e-0311c8917629");
|
|
const ICON_29_VOLUME_POST_PROCESS: Handle<Image> =
|
|
uuid_handle!("bc9064bd-b6a8-4b00-95d4-3763325bceb9");
|
|
const ICON_30_ENVIRONMENT_WIND: Handle<Image> =
|
|
uuid_handle!("0d4220a6-7abc-42bc-a0d2-b69847061a92");
|
|
const ICON_31_ENVIRONMENT_SKY: Handle<Image> = uuid_handle!("e4f09ad3-380d-4086-9eb4-e60e69ec1765");
|
|
const ICON_32_DEBUG_NOTE: Handle<Image> = uuid_handle!("d093e657-6598-4097-8a57-9d445e3a80d7");
|
|
|
|
#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub struct ActorIconProxy {
|
|
pub target: Entity,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
enum ActorIconImage {
|
|
Empty,
|
|
Generic,
|
|
Missing,
|
|
Warning,
|
|
Mesh,
|
|
LightPoint,
|
|
LightSpot,
|
|
LightDirectional,
|
|
PhysicsCollider,
|
|
GameSpawn,
|
|
GameTrigger,
|
|
GameMarker,
|
|
VolumeGeneric,
|
|
PostProcessVolume,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
enum ActorIconCategory {
|
|
Actor,
|
|
Mesh,
|
|
Light,
|
|
Physics,
|
|
Gameplay,
|
|
Volume,
|
|
PrefabModel,
|
|
Debug,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
struct ActorIconSpec {
|
|
image: ActorIconImage,
|
|
category: ActorIconCategory,
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone, Copy)]
|
|
struct ActorIconComponents {
|
|
kind: Option<ActorKind>,
|
|
light_kind: Option<AuthoringLightKind>,
|
|
has_primitive: bool,
|
|
has_static_mesh_renderer: bool,
|
|
has_model_ref: bool,
|
|
has_prefab_ref: bool,
|
|
has_prefab_instance: bool,
|
|
has_player_spawn: bool,
|
|
has_weapon_spawn: bool,
|
|
has_trigger_volume: bool,
|
|
has_post_process_volume: bool,
|
|
has_team_spawn: bool,
|
|
has_objective: bool,
|
|
has_physics: bool,
|
|
}
|
|
|
|
#[derive(Resource)]
|
|
struct ActorIconAssets {
|
|
mesh: Handle<Mesh>,
|
|
materials: HashMap<ActorIconImage, Handle<StandardMaterial>>,
|
|
}
|
|
|
|
pub struct ActorIconsPlugin;
|
|
|
|
impl Plugin for ActorIconsPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
register_actor_icon_images(app);
|
|
app.add_systems(Startup, init_actor_icon_assets)
|
|
.add_systems(Update, sync_actor_icons.run_if(scene_tools_active));
|
|
}
|
|
}
|
|
|
|
fn icon_image_from_png(bytes: &[u8], path: String) -> Image {
|
|
Image::from_buffer(
|
|
bytes,
|
|
ImageType::Extension("png"),
|
|
CompressedImageFormats::NONE,
|
|
true,
|
|
ImageSampler::linear(),
|
|
RenderAssetUsages::default(),
|
|
)
|
|
.unwrap_or_else(|err| panic!("failed to load editor actor icon {path}: {err}"))
|
|
}
|
|
|
|
macro_rules! load_actor_icon {
|
|
($app:ident, $handle:expr, $path:literal) => {
|
|
load_internal_binary_asset!(
|
|
$app,
|
|
$handle,
|
|
concat!("../../assets/icons/", $path),
|
|
icon_image_from_png
|
|
);
|
|
};
|
|
}
|
|
|
|
fn register_actor_icon_images(app: &mut App) {
|
|
load_actor_icon!(app, ICON_01_ACTOR_EMPTY, "01_actor_empty.png");
|
|
load_actor_icon!(app, ICON_02_ACTOR_GENERIC, "02_actor_generic.png");
|
|
load_actor_icon!(app, ICON_03_ACTOR_MISSING, "03_actor_missing.png");
|
|
load_actor_icon!(app, ICON_04_ACTOR_WARNING, "04_actor_warning.png");
|
|
load_actor_icon!(app, ICON_05_RENDER_MESH, "05_render_mesh.png");
|
|
load_actor_icon!(app, ICON_06_RENDER_DECAL, "06_render_decal.png");
|
|
load_actor_icon!(app, ICON_07_RENDER_PARTICLE, "07_render_particle.png");
|
|
load_actor_icon!(app, ICON_08_RENDER_BILLBOARD, "08_render_billboard.png");
|
|
load_actor_icon!(app, ICON_09_LIGHT_POINT, "09_light_point.png");
|
|
load_actor_icon!(app, ICON_10_LIGHT_SPOT, "10_light_spot.png");
|
|
load_actor_icon!(app, ICON_11_LIGHT_DIRECTIONAL, "11_light_directional.png");
|
|
load_actor_icon!(app, ICON_12_LIGHT_AREA, "12_light_area.png");
|
|
load_actor_icon!(app, ICON_13_CAMERA_MAIN, "13_camera_main.png");
|
|
load_actor_icon!(app, ICON_14_CAMERA_CAPTURE, "14_camera_capture.png");
|
|
load_actor_icon!(app, ICON_15_AUDIO_SOURCE, "15_audio_source.png");
|
|
load_actor_icon!(app, ICON_16_AUDIO_LISTENER, "16_audio_listener.png");
|
|
load_actor_icon!(app, ICON_17_PHYSICS_COLLIDER, "17_physics_collider.png");
|
|
load_actor_icon!(app, ICON_18_PHYSICS_RIGIDBODY, "18_physics_rigidbody.png");
|
|
load_actor_icon!(app, ICON_19_PHYSICS_TRIGGER, "19_physics_trigger.png");
|
|
load_actor_icon!(app, ICON_20_PHYSICS_JOINT, "20_physics_joint.png");
|
|
load_actor_icon!(app, ICON_21_GAME_SPAWN, "21_game_spawn.png");
|
|
load_actor_icon!(app, ICON_22_GAME_TRIGGER, "22_game_trigger.png");
|
|
load_actor_icon!(app, ICON_23_GAME_MARKER, "23_game_marker.png");
|
|
load_actor_icon!(app, ICON_24_GAME_INTERACTABLE, "24_game_interactable.png");
|
|
load_actor_icon!(app, ICON_25_NAV_WAYPOINT, "25_nav_waypoint.png");
|
|
load_actor_icon!(app, ICON_26_NAV_LINK, "26_nav_link.png");
|
|
load_actor_icon!(app, ICON_27_NAV_REGION, "27_nav_region.png");
|
|
load_actor_icon!(app, ICON_28_VOLUME_GENERIC, "28_volume_generic.png");
|
|
load_actor_icon!(
|
|
app,
|
|
ICON_29_VOLUME_POST_PROCESS,
|
|
"29_volume_post_process.png"
|
|
);
|
|
load_actor_icon!(app, ICON_30_ENVIRONMENT_WIND, "30_environment_wind.png");
|
|
load_actor_icon!(app, ICON_31_ENVIRONMENT_SKY, "31_environment_sky.png");
|
|
load_actor_icon!(app, ICON_32_DEBUG_NOTE, "32_debug_note.png");
|
|
}
|
|
|
|
fn init_actor_icon_assets(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
let mesh = meshes.add(Rectangle::new(1.0, 1.0));
|
|
let mut actor_materials = HashMap::new();
|
|
for (image, texture) in [
|
|
(ActorIconImage::Empty, ICON_01_ACTOR_EMPTY),
|
|
(ActorIconImage::Generic, ICON_02_ACTOR_GENERIC),
|
|
(ActorIconImage::Missing, ICON_03_ACTOR_MISSING),
|
|
(ActorIconImage::Warning, ICON_04_ACTOR_WARNING),
|
|
(ActorIconImage::Mesh, ICON_05_RENDER_MESH),
|
|
(ActorIconImage::LightPoint, ICON_09_LIGHT_POINT),
|
|
(ActorIconImage::LightSpot, ICON_10_LIGHT_SPOT),
|
|
(ActorIconImage::LightDirectional, ICON_11_LIGHT_DIRECTIONAL),
|
|
(ActorIconImage::PhysicsCollider, ICON_17_PHYSICS_COLLIDER),
|
|
(ActorIconImage::GameSpawn, ICON_21_GAME_SPAWN),
|
|
(ActorIconImage::GameTrigger, ICON_22_GAME_TRIGGER),
|
|
(ActorIconImage::GameMarker, ICON_23_GAME_MARKER),
|
|
(ActorIconImage::VolumeGeneric, ICON_28_VOLUME_GENERIC),
|
|
(
|
|
ActorIconImage::PostProcessVolume,
|
|
ICON_29_VOLUME_POST_PROCESS,
|
|
),
|
|
] {
|
|
actor_materials.insert(
|
|
image,
|
|
materials.add(StandardMaterial {
|
|
base_color_texture: Some(texture.clone()),
|
|
alpha_mode: AlphaMode::Blend,
|
|
unlit: true,
|
|
cull_mode: None,
|
|
fog_enabled: false,
|
|
depth_bias: -40.0,
|
|
..default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
commands.insert_resource(ActorIconAssets {
|
|
mesh,
|
|
materials: actor_materials,
|
|
});
|
|
}
|
|
|
|
#[allow(clippy::type_complexity, clippy::too_many_arguments)]
|
|
fn sync_actor_icons(
|
|
display: Res<ViewportDisplayMode>,
|
|
settings: Res<EditorVisualizationSettings>,
|
|
ui_state: Res<UiState>,
|
|
assets: Res<ActorIconAssets>,
|
|
mut commands: Commands,
|
|
mut icons: Query<(
|
|
Entity,
|
|
&ActorIconProxy,
|
|
&MeshMaterial3d<StandardMaterial>,
|
|
&mut Transform,
|
|
)>,
|
|
camera_query: Query<(&Camera, &GlobalTransform, Option<&Projection>), With<EditorCamera>>,
|
|
actor_roots: Query<
|
|
(
|
|
Entity,
|
|
&GlobalTransform,
|
|
Option<&ActorKind>,
|
|
Option<&LightDesc>,
|
|
Has<Primitive>,
|
|
Option<&StaticMeshRenderer>,
|
|
Has<ModelRef>,
|
|
Has<PrefabRef>,
|
|
Has<PrefabInstance>,
|
|
Has<PlayerSpawn>,
|
|
Has<WeaponSpawn>,
|
|
Has<TriggerVolume>,
|
|
Has<PostProcessVolumeDesc>,
|
|
Has<TeamSpawn>,
|
|
Has<ObjectiveMarker>,
|
|
),
|
|
(With<LevelObject>, Without<EditorOnly>),
|
|
>,
|
|
physics: Query<(), Or<(With<PhysicsBody>, With<ColliderDesc>)>>,
|
|
) {
|
|
let camera = active_editor_camera(&camera_query);
|
|
let mut desired = HashMap::new();
|
|
if !display.clean_game_view && settings.enabled && settings.show_actor_icons {
|
|
for (
|
|
target,
|
|
global,
|
|
kind,
|
|
light,
|
|
has_primitive,
|
|
static_mesh_renderer,
|
|
has_model_ref,
|
|
has_prefab_ref,
|
|
has_prefab_instance,
|
|
has_player_spawn,
|
|
has_weapon_spawn,
|
|
has_trigger_volume,
|
|
has_post_process_volume,
|
|
has_team_spawn,
|
|
has_objective,
|
|
) in &actor_roots
|
|
{
|
|
let components = ActorIconComponents {
|
|
kind: kind.copied(),
|
|
light_kind: light.map(|light| light.kind),
|
|
has_primitive,
|
|
has_static_mesh_renderer: static_mesh_renderer
|
|
.is_some_and(has_resolved_static_mesh_slot),
|
|
has_model_ref,
|
|
has_prefab_ref,
|
|
has_prefab_instance,
|
|
has_player_spawn,
|
|
has_weapon_spawn,
|
|
has_trigger_volume,
|
|
has_post_process_volume,
|
|
has_team_spawn,
|
|
has_objective,
|
|
has_physics: physics.contains(target),
|
|
};
|
|
let spec = icon_for_actor_components(components);
|
|
if !icon_category_enabled(&settings, spec.category) {
|
|
continue;
|
|
}
|
|
let transform = desired_icon_transform(global, camera, ui_state.viewport_rect.height());
|
|
desired.insert(target, (spec.image, transform));
|
|
}
|
|
}
|
|
|
|
let mut existing_targets = HashSet::new();
|
|
for (entity, proxy, material, mut transform) in &mut icons {
|
|
let Some((image, desired_transform)) = desired.get(&proxy.target) else {
|
|
commands.entity(entity).despawn();
|
|
continue;
|
|
};
|
|
let expected_material = assets.materials.get(image);
|
|
if expected_material.is_none_or(|expected| material.0 != *expected) {
|
|
commands.entity(entity).despawn();
|
|
continue;
|
|
}
|
|
existing_targets.insert(proxy.target);
|
|
*transform = *desired_transform;
|
|
}
|
|
|
|
for (
|
|
target,
|
|
global,
|
|
kind,
|
|
light,
|
|
has_primitive,
|
|
static_mesh_renderer,
|
|
has_model_ref,
|
|
has_prefab_ref,
|
|
has_prefab_instance,
|
|
has_player_spawn,
|
|
has_weapon_spawn,
|
|
has_trigger_volume,
|
|
has_post_process_volume,
|
|
has_team_spawn,
|
|
has_objective,
|
|
) in &actor_roots
|
|
{
|
|
if existing_targets.contains(&target) {
|
|
continue;
|
|
}
|
|
let components = ActorIconComponents {
|
|
kind: kind.copied(),
|
|
light_kind: light.map(|light| light.kind),
|
|
has_primitive,
|
|
has_static_mesh_renderer: static_mesh_renderer
|
|
.is_some_and(has_resolved_static_mesh_slot),
|
|
has_model_ref,
|
|
has_prefab_ref,
|
|
has_prefab_instance,
|
|
has_player_spawn,
|
|
has_weapon_spawn,
|
|
has_trigger_volume,
|
|
has_post_process_volume,
|
|
has_team_spawn,
|
|
has_objective,
|
|
has_physics: physics.contains(target),
|
|
};
|
|
let spec = icon_for_actor_components(components);
|
|
if !desired.contains_key(&target) {
|
|
continue;
|
|
}
|
|
let Some(material) = assets.materials.get(&spec.image).cloned() else {
|
|
continue;
|
|
};
|
|
let transform = desired_icon_transform(global, camera, ui_state.viewport_rect.height());
|
|
commands.spawn((
|
|
EditorOnly,
|
|
RaytracingExcluded,
|
|
NoFrustumCulling,
|
|
Name::new("Actor Root Icon"),
|
|
ActorIconProxy { target },
|
|
Mesh3d(assets.mesh.clone()),
|
|
MeshMaterial3d(material),
|
|
transform,
|
|
Visibility::Visible,
|
|
ChildOf(target),
|
|
));
|
|
}
|
|
}
|
|
|
|
fn active_editor_camera<'a>(
|
|
camera_query: &'a Query<(&Camera, &GlobalTransform, Option<&Projection>), With<EditorCamera>>,
|
|
) -> Option<(&'a Camera, &'a GlobalTransform, Option<&'a Projection>)> {
|
|
camera_query
|
|
.iter()
|
|
.find(|(camera, _, _)| camera.is_active)
|
|
.or_else(|| camera_query.iter().next())
|
|
}
|
|
|
|
fn desired_icon_transform(
|
|
parent_global: &GlobalTransform,
|
|
camera: Option<(&Camera, &GlobalTransform, Option<&Projection>)>,
|
|
viewport_height: f32,
|
|
) -> Transform {
|
|
let translation = parent_global.translation();
|
|
let Some((_, camera_global, projection)) = camera else {
|
|
return Transform::from_translation(Vec3::ZERO).with_scale(Vec3::splat(0.5));
|
|
};
|
|
let size = icon_world_size(
|
|
translation,
|
|
camera_global,
|
|
projection,
|
|
viewport_height.max(1.0),
|
|
);
|
|
let desired_global = Transform {
|
|
translation,
|
|
rotation: camera_global.rotation(),
|
|
scale: Vec3::splat(size),
|
|
};
|
|
let local = parent_global.affine().inverse() * GlobalTransform::from(desired_global).affine();
|
|
Transform::from_matrix(Mat4::from(local))
|
|
}
|
|
|
|
fn icon_world_size(
|
|
target: Vec3,
|
|
camera_global: &GlobalTransform,
|
|
projection: Option<&Projection>,
|
|
viewport_height: f32,
|
|
) -> f32 {
|
|
let camera_position = camera_global.translation();
|
|
let pixels_to_view = ICON_TARGET_PIXELS / viewport_height;
|
|
let world_height = match projection {
|
|
Some(Projection::Perspective(projection)) => {
|
|
let distance = camera_position.distance(target).max(0.1);
|
|
2.0 * distance * (projection.fov * 0.5).tan()
|
|
}
|
|
Some(Projection::Orthographic(projection)) => projection.area.height().abs().max(0.1),
|
|
_ => {
|
|
let distance = camera_position.distance(target).max(0.1);
|
|
2.0 * distance * (DEFAULT_PERSPECTIVE_FOV * 0.5).tan()
|
|
}
|
|
};
|
|
(world_height * pixels_to_view).clamp(ICON_MIN_WORLD_SIZE, ICON_MAX_WORLD_SIZE)
|
|
}
|
|
|
|
fn icon_category_enabled(
|
|
settings: &EditorVisualizationSettings,
|
|
category: ActorIconCategory,
|
|
) -> bool {
|
|
match category {
|
|
ActorIconCategory::Actor => settings.show_actor_icon_actor,
|
|
ActorIconCategory::Mesh => settings.show_actor_icon_mesh,
|
|
ActorIconCategory::Light => settings.show_actor_icon_light,
|
|
ActorIconCategory::Physics => settings.show_actor_icon_physics,
|
|
ActorIconCategory::Gameplay => settings.show_actor_icon_gameplay,
|
|
ActorIconCategory::Volume => settings.show_actor_icon_volume,
|
|
ActorIconCategory::PrefabModel => settings.show_actor_icon_prefab_model,
|
|
ActorIconCategory::Debug => settings.show_actor_icon_debug,
|
|
}
|
|
}
|
|
|
|
fn has_resolved_static_mesh_slot(renderer: &StaticMeshRenderer) -> bool {
|
|
renderer.slots.iter().any(|slot| slot.mesh.is_resolved())
|
|
}
|
|
|
|
fn icon_for_actor_components(components: ActorIconComponents) -> ActorIconSpec {
|
|
let warning = ActorIconSpec {
|
|
image: ActorIconImage::Warning,
|
|
category: ActorIconCategory::Debug,
|
|
};
|
|
let Some(kind) = components.kind else {
|
|
return ActorIconSpec {
|
|
image: ActorIconImage::Missing,
|
|
category: ActorIconCategory::Debug,
|
|
};
|
|
};
|
|
|
|
match kind {
|
|
ActorKind::StaticMesh => {
|
|
if components.has_primitive || components.has_static_mesh_renderer {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::Mesh,
|
|
category: ActorIconCategory::Mesh,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::ImportedModel => {
|
|
if components.has_model_ref {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::Mesh,
|
|
category: ActorIconCategory::PrefabModel,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::Light => match components.light_kind {
|
|
Some(AuthoringLightKind::Point) => ActorIconSpec {
|
|
image: ActorIconImage::LightPoint,
|
|
category: ActorIconCategory::Light,
|
|
},
|
|
Some(AuthoringLightKind::Spot) => ActorIconSpec {
|
|
image: ActorIconImage::LightSpot,
|
|
category: ActorIconCategory::Light,
|
|
},
|
|
Some(AuthoringLightKind::Directional) => ActorIconSpec {
|
|
image: ActorIconImage::LightDirectional,
|
|
category: ActorIconCategory::Light,
|
|
},
|
|
None => warning,
|
|
},
|
|
ActorKind::PrefabAnchor => {
|
|
if components.has_prefab_ref || components.has_prefab_instance {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::Generic,
|
|
category: ActorIconCategory::PrefabModel,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::PlayerSpawn => {
|
|
if components.has_player_spawn {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::GameSpawn,
|
|
category: ActorIconCategory::Gameplay,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::WeaponSpawn => {
|
|
if components.has_weapon_spawn {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::GameSpawn,
|
|
category: ActorIconCategory::Gameplay,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::TriggerVolume => {
|
|
if components.has_trigger_volume {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::GameTrigger,
|
|
category: ActorIconCategory::Gameplay,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::PostProcessVolume => {
|
|
if components.has_post_process_volume {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::PostProcessVolume,
|
|
category: ActorIconCategory::Volume,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::TeamSpawn => {
|
|
if components.has_team_spawn {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::GameSpawn,
|
|
category: ActorIconCategory::Gameplay,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::Objective => {
|
|
if components.has_objective {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::GameMarker,
|
|
category: ActorIconCategory::Gameplay,
|
|
}
|
|
} else {
|
|
warning
|
|
}
|
|
}
|
|
ActorKind::Empty => {
|
|
if components.has_physics {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::PhysicsCollider,
|
|
category: ActorIconCategory::Physics,
|
|
}
|
|
} else {
|
|
ActorIconSpec {
|
|
image: ActorIconImage::Empty,
|
|
category: ActorIconCategory::Actor,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn resolves_directional_light_icon() {
|
|
let spec = icon_for_actor_components(ActorIconComponents {
|
|
kind: Some(ActorKind::Light),
|
|
light_kind: Some(AuthoringLightKind::Directional),
|
|
..default()
|
|
});
|
|
|
|
assert_eq!(spec.image, ActorIconImage::LightDirectional);
|
|
assert_eq!(spec.category, ActorIconCategory::Light);
|
|
}
|
|
|
|
#[test]
|
|
fn unresolved_static_mesh_uses_warning_icon() {
|
|
let spec = icon_for_actor_components(ActorIconComponents {
|
|
kind: Some(ActorKind::StaticMesh),
|
|
..default()
|
|
});
|
|
|
|
assert_eq!(spec.image, ActorIconImage::Warning);
|
|
assert_eq!(spec.category, ActorIconCategory::Debug);
|
|
}
|
|
|
|
#[test]
|
|
fn empty_actor_with_collider_uses_physics_category() {
|
|
let spec = icon_for_actor_components(ActorIconComponents {
|
|
kind: Some(ActorKind::Empty),
|
|
has_physics: true,
|
|
..default()
|
|
});
|
|
|
|
assert_eq!(spec.image, ActorIconImage::PhysicsCollider);
|
|
assert_eq!(spec.category, ActorIconCategory::Physics);
|
|
}
|
|
}
|