4645 lines
173 KiB
Rust
4645 lines
173 KiB
Rust
//! Inspector extensions for authoring components.
|
||
|
||
use std::collections::{HashMap, HashSet};
|
||
use std::path::Path;
|
||
|
||
use bevy::prelude::*;
|
||
use bevy_egui::egui;
|
||
use egui_phosphor_icons::{icons, Icon};
|
||
use shared::{
|
||
authoring_component_active,
|
||
brush_math::{validate_brush, BrushDiagnosticSeverity},
|
||
infer_actor_kind, ActorId, ActorKind, AnimationControllerDesc, AudioListenerDesc,
|
||
AudioSourceDesc, AuthoringComponentStates, AuthoringLightKind, AuthoringRigidBody, BrushDesc,
|
||
BrushKind, ColliderDesc, ColliderShapeDesc, ColorDesc, ComponentInstanceId, EditorAssetRef,
|
||
InspectorOrder, LevelObject, LightDesc, MaterialDesc, MaterialParameter,
|
||
MaterialParameterValue, MaterialRef, MaterialShaderKind, NavigationArea, NavigationBounds,
|
||
NavigationLink, NavigationObstacle, ObjectiveMarker, PhysicsBody, PlayerSpawn,
|
||
PostProcessVolumeDesc, PrefabInstance, Primitive, PrimitiveShape, ProjectSun, RigidBodyDesc,
|
||
SkinnedMeshRenderer, StaticMeshRenderer, StaticMeshRendererEntry, TeamSpawn, TerrainDesc,
|
||
TriggerVolume, WeaponSpawn, AUTHORING_DIRECTIONAL_LUX_MAX, AUTHORING_POINT_SPOT_LUMENS_MAX,
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC, COMPONENT_AUDIO_LISTENER_DESC,
|
||
COMPONENT_AUDIO_SOURCE_DESC, COMPONENT_BRUSH_DESC, COMPONENT_COLLIDER_DESC,
|
||
COMPONENT_LIGHT_DESC, COMPONENT_MATERIAL_DESC, COMPONENT_NAVIGATION_AREA,
|
||
COMPONENT_NAVIGATION_BOUNDS, COMPONENT_NAVIGATION_LINK, COMPONENT_NAVIGATION_OBSTACLE,
|
||
COMPONENT_OBJECTIVE_MARKER, COMPONENT_PHYSICS_BODY, COMPONENT_PLAYER_SPAWN,
|
||
COMPONENT_POST_PROCESS_VOLUME, COMPONENT_PREFAB_INSTANCE, COMPONENT_PRIMITIVE,
|
||
COMPONENT_PROJECT_SUN, COMPONENT_RIGID_BODY_DESC, COMPONENT_SKINNED_MESH_RENDERER,
|
||
COMPONENT_STATIC_MESH_RENDERER, COMPONENT_TEAM_SPAWN, COMPONENT_TERRAIN_DESC,
|
||
COMPONENT_TRIGGER_VOLUME, COMPONENT_WEAPON_SPAWN,
|
||
};
|
||
|
||
use crate::history::{
|
||
material_eq, reflected_component_transaction, set_animation_controller_with_history,
|
||
set_audio_listener_with_history, set_audio_source_with_history, set_brush_with_history,
|
||
set_collider_with_history, set_inspector_order_with_history, set_light_with_history,
|
||
set_material_with_history, set_physics_with_history, set_post_process_volume_with_history,
|
||
set_primitive_with_history, set_rigid_body_with_history, set_static_mesh_renderer_with_history,
|
||
EditorEntitySnapshot,
|
||
};
|
||
use crate::selection::SelectedEntity;
|
||
use crate::ui::theme::{
|
||
panel_heading, BORDER, ELEVATED_BG, PANEL_BG_DARK, SELECTION_BG_MUTED, TEXT_DIM, TEXT_MUTED,
|
||
WIDGET_BG,
|
||
};
|
||
use crate::ui::widgets::{icon_button_small, phosphor_icon, phosphor_icon_text};
|
||
use crate::viewport::brush_edit::{BrushElementKey, BrushElementSelection};
|
||
|
||
use super::component_registry::{
|
||
EditorComponentCategory, EditorComponentDescriptor, EditorComponentRegistry,
|
||
};
|
||
use super::dock_tabs::open_and_focus_tab;
|
||
use super::helpers::create_scene_sun_override_from_project_settings;
|
||
use super::{EditorTab, UiState};
|
||
use crate::assets::asset_db::{find_asset_by_path, AssetRegistry};
|
||
use crate::assets::static_mesh::{
|
||
load_static_mesh_manifest, material_id_from_label, part_id_from_label,
|
||
};
|
||
use crate::assets::thumbnails::ThumbnailStudio;
|
||
use crate::assets::{
|
||
asset_cache_key, AssetSelection, AssetSubAssetKind, AssetThumbnailCache, EditorAsset,
|
||
EditorAssetKind, EditorAssets,
|
||
};
|
||
|
||
const COMPACT_INSPECTOR_WIDTH: f32 = 360.0;
|
||
const ASSET_SELECTOR_LABEL_WIDTH: f32 = 72.0;
|
||
const ASSET_SELECTOR_HEIGHT: f32 = 48.0;
|
||
const MIN_INLINE_CONTROL_WIDTH: f32 = 120.0;
|
||
const TEXT_FIELD_MAX_WIDTH: f32 = 320.0;
|
||
const PROPERTY_LABEL_WIDTH: f32 = 136.0;
|
||
pub(crate) const COMPONENT_TRANSFORM: &str = "bevy_transform::components::Transform";
|
||
|
||
fn fit_width(ui: &egui::Ui, min: f32, max: f32) -> f32 {
|
||
let available = ui.available_width().max(1.0);
|
||
available.min(max).max(min.min(available))
|
||
}
|
||
|
||
fn exact_region<R>(
|
||
ui: &mut egui::Ui,
|
||
size: egui::Vec2,
|
||
layout: egui::Layout,
|
||
add_contents: impl FnOnce(&mut egui::Ui) -> R,
|
||
) -> R {
|
||
let (rect, _response) = ui.allocate_exact_size(size, egui::Sense::hover());
|
||
let mut child = ui.new_child(egui::UiBuilder::new().max_rect(rect).layout(layout));
|
||
add_contents(&mut child)
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct AssetRefCandidate {
|
||
reference: EditorAssetRef,
|
||
label: String,
|
||
detail: String,
|
||
selection: AssetSelection,
|
||
folder_path: String,
|
||
texture_id: Option<egui::TextureId>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
enum AssetRefCandidateKind {
|
||
Mesh,
|
||
Material,
|
||
Texture,
|
||
}
|
||
|
||
#[derive(Default)]
|
||
struct AssetSelectorResponse {
|
||
selected: Option<EditorAssetRef>,
|
||
clear: bool,
|
||
locate: bool,
|
||
accepted_drop: bool,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct TextureAssetCandidate {
|
||
label: String,
|
||
path: String,
|
||
folder_path: String,
|
||
selection: AssetSelection,
|
||
texture_id: Option<egui::TextureId>,
|
||
}
|
||
|
||
#[derive(Resource, Default, Debug, Clone)]
|
||
pub(crate) struct InspectorClipboard {
|
||
component: Option<CopiedComponent>,
|
||
}
|
||
|
||
#[derive(Resource, Default, Debug, Clone)]
|
||
pub(crate) struct InspectorPanelState {
|
||
add_component_search: String,
|
||
add_component_open: bool,
|
||
add_component_focus_search: bool,
|
||
add_component_scroll_selected: bool,
|
||
add_component_selected_index: usize,
|
||
add_component_target: Option<Entity>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
enum AddComponentShelfDirection {
|
||
Up,
|
||
Down,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
enum CopiedComponent {
|
||
Reflected(crate::history::ReflectedComponentValue),
|
||
AnimationControllerDesc(AnimationControllerDesc),
|
||
Primitive(Primitive),
|
||
BrushDesc(BrushDesc),
|
||
StaticMeshRenderer(StaticMeshRenderer),
|
||
MaterialDesc(MaterialDesc),
|
||
LightDesc(LightDesc),
|
||
AudioSourceDesc(AudioSourceDesc),
|
||
AudioListenerDesc(AudioListenerDesc),
|
||
RigidBodyDesc(RigidBodyDesc),
|
||
ColliderDesc(ColliderDesc),
|
||
PhysicsBody(PhysicsBody),
|
||
WeaponSpawn(WeaponSpawn),
|
||
TriggerVolume(TriggerVolume),
|
||
TeamSpawn(TeamSpawn),
|
||
ObjectiveMarker(ObjectiveMarker),
|
||
PostProcessVolume(PostProcessVolumeDesc),
|
||
PrefabInstance(PrefabInstance),
|
||
NavigationBounds(NavigationBounds),
|
||
NavigationObstacle(NavigationObstacle),
|
||
NavigationArea(NavigationArea),
|
||
NavigationLink(NavigationLink),
|
||
}
|
||
|
||
impl CopiedComponent {
|
||
fn type_name(&self) -> &str {
|
||
match self {
|
||
Self::Reflected(value) => &value.type_path,
|
||
Self::AnimationControllerDesc(_) => COMPONENT_ANIMATION_CONTROLLER_DESC,
|
||
Self::Primitive(_) => COMPONENT_PRIMITIVE,
|
||
Self::BrushDesc(_) => COMPONENT_BRUSH_DESC,
|
||
Self::StaticMeshRenderer(_) => COMPONENT_STATIC_MESH_RENDERER,
|
||
Self::MaterialDesc(_) => COMPONENT_MATERIAL_DESC,
|
||
Self::LightDesc(_) => COMPONENT_LIGHT_DESC,
|
||
Self::AudioSourceDesc(_) => COMPONENT_AUDIO_SOURCE_DESC,
|
||
Self::AudioListenerDesc(_) => COMPONENT_AUDIO_LISTENER_DESC,
|
||
Self::RigidBodyDesc(_) => COMPONENT_RIGID_BODY_DESC,
|
||
Self::ColliderDesc(_) => COMPONENT_COLLIDER_DESC,
|
||
Self::PhysicsBody(_) => COMPONENT_PHYSICS_BODY,
|
||
Self::WeaponSpawn(_) => COMPONENT_WEAPON_SPAWN,
|
||
Self::TriggerVolume(_) => COMPONENT_TRIGGER_VOLUME,
|
||
Self::TeamSpawn(_) => COMPONENT_TEAM_SPAWN,
|
||
Self::ObjectiveMarker(_) => COMPONENT_OBJECTIVE_MARKER,
|
||
Self::PostProcessVolume(_) => COMPONENT_POST_PROCESS_VOLUME,
|
||
Self::PrefabInstance(_) => COMPONENT_PREFAB_INSTANCE,
|
||
Self::NavigationBounds(_) => COMPONENT_NAVIGATION_BOUNDS,
|
||
Self::NavigationObstacle(_) => COMPONENT_NAVIGATION_OBSTACLE,
|
||
Self::NavigationArea(_) => COMPONENT_NAVIGATION_AREA,
|
||
Self::NavigationLink(_) => COMPONENT_NAVIGATION_LINK,
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy)]
|
||
pub(crate) struct ComponentCardOptions {
|
||
pub type_name: &'static str,
|
||
pub title: &'static str,
|
||
pub icon: Icon,
|
||
pub active_toggle: bool,
|
||
pub removable: bool,
|
||
pub reorderable: bool,
|
||
pub resettable: bool,
|
||
pub copyable: bool,
|
||
}
|
||
|
||
impl ComponentCardOptions {
|
||
pub(crate) fn removable(type_name: &'static str, title: &'static str, icon: Icon) -> Self {
|
||
Self {
|
||
type_name,
|
||
title,
|
||
icon,
|
||
active_toggle: true,
|
||
removable: true,
|
||
reorderable: true,
|
||
resettable: true,
|
||
copyable: true,
|
||
}
|
||
}
|
||
|
||
pub(crate) fn fixed(type_name: &'static str, title: &'static str, icon: Icon) -> Self {
|
||
Self {
|
||
type_name,
|
||
title,
|
||
icon,
|
||
active_toggle: false,
|
||
removable: false,
|
||
reorderable: false,
|
||
resettable: true,
|
||
copyable: false,
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
pub(crate) struct ComponentCardContext {
|
||
options: ComponentCardOptions,
|
||
active: bool,
|
||
collapsed: bool,
|
||
pasteable: bool,
|
||
can_move_up: bool,
|
||
can_move_down: bool,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Default)]
|
||
pub(crate) struct ComponentCardResponse {
|
||
pub(crate) type_name: &'static str,
|
||
pub(crate) collapsed: Option<bool>,
|
||
pub(crate) active: Option<bool>,
|
||
pub(crate) reset: bool,
|
||
pub(crate) copy: bool,
|
||
pub(crate) paste: bool,
|
||
pub(crate) move_up: bool,
|
||
pub(crate) move_down: bool,
|
||
pub(crate) remove: bool,
|
||
}
|
||
|
||
pub(crate) fn component_card_context(
|
||
world: &World,
|
||
entity: Entity,
|
||
options: ComponentCardOptions,
|
||
) -> ComponentCardContext {
|
||
let present = present_component_type_names(world, entity);
|
||
let order = world.get::<InspectorOrder>(entity);
|
||
let registry = world.resource::<EditorComponentRegistry>();
|
||
let state_key = registry.stable_id_for_type(options.type_name);
|
||
let active = authoring_component_active(
|
||
world.get::<AuthoringComponentStates>(entity),
|
||
order,
|
||
state_key,
|
||
);
|
||
let collapsed = world
|
||
.get_resource::<UiState>()
|
||
.map(|state| {
|
||
state
|
||
.inspector_collapsed_components
|
||
.contains(&component_card_key(world, entity, options.type_name))
|
||
})
|
||
.unwrap_or(false);
|
||
let pasteable = options.copyable
|
||
&& world
|
||
.get_resource::<InspectorClipboard>()
|
||
.and_then(|clipboard| clipboard.component.as_ref())
|
||
.is_some_and(|component| component.type_name() == options.type_name);
|
||
let ordered = order
|
||
.map(|order| registry.ordered_components(order, &present))
|
||
.unwrap_or_else(|| present.clone());
|
||
let order_index = ordered
|
||
.iter()
|
||
.position(|type_name| *type_name == options.type_name);
|
||
|
||
ComponentCardContext {
|
||
options,
|
||
active,
|
||
collapsed,
|
||
pasteable,
|
||
can_move_up: options.reorderable && order_index.is_some_and(|index| index > 0),
|
||
can_move_down: options.reorderable
|
||
&& order_index.is_some_and(|index| index + 1 < ordered.len()),
|
||
}
|
||
}
|
||
|
||
pub(crate) fn apply_component_card_response(
|
||
world: &mut World,
|
||
entity: Entity,
|
||
response: ComponentCardResponse,
|
||
) {
|
||
let type_name = response_type_name(&response).unwrap_or_default();
|
||
if type_name.is_empty() {
|
||
return;
|
||
}
|
||
apply_component_card_response_for_type(world, entity, type_name, response);
|
||
}
|
||
|
||
fn apply_component_card_response_for_type(
|
||
world: &mut World,
|
||
entity: Entity,
|
||
type_name: &'static str,
|
||
response: ComponentCardResponse,
|
||
) {
|
||
if let Some(collapsed) = response.collapsed {
|
||
let key = component_card_key(world, entity, type_name);
|
||
if let Some(mut ui_state) = world.get_resource_mut::<UiState>() {
|
||
if collapsed {
|
||
ui_state.inspector_collapsed_components.insert(key);
|
||
} else {
|
||
ui_state.inspector_collapsed_components.remove(&key);
|
||
}
|
||
}
|
||
}
|
||
|
||
if let Some(active) = response.active {
|
||
let mut states = world
|
||
.get::<AuthoringComponentStates>(entity)
|
||
.cloned()
|
||
.unwrap_or_else(|| AuthoringComponentStates {
|
||
states: world
|
||
.get::<InspectorOrder>(entity)
|
||
.map(|order| order.component_states.clone())
|
||
.unwrap_or_default(),
|
||
});
|
||
let component_id = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.stable_id_for_type(type_name);
|
||
states.set_component_active(component_id, active);
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Set Component Active",
|
||
"editor.component_states",
|
||
"shared::components::AuthoringComponentStates",
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(states);
|
||
Ok(())
|
||
},
|
||
);
|
||
}
|
||
|
||
if response.move_up || response.move_down {
|
||
let mut order = world
|
||
.get::<InspectorOrder>(entity)
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
let present = present_component_type_names(world, entity);
|
||
let offset = if response.move_up { -1 } else { 1 };
|
||
let moved = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.move_component(&mut order, type_name, offset, &present);
|
||
if moved {
|
||
set_inspector_order_with_history(world, entity, order);
|
||
}
|
||
}
|
||
|
||
if response.copy {
|
||
copy_component(world, entity, type_name);
|
||
}
|
||
if response.paste {
|
||
paste_component(world, entity, type_name);
|
||
}
|
||
if response.reset {
|
||
reset_component(world, entity, type_name);
|
||
}
|
||
if response.remove {
|
||
remove_registered_component(world, entity, type_name);
|
||
}
|
||
}
|
||
|
||
fn response_type_name(_response: &ComponentCardResponse) -> Option<&'static str> {
|
||
Some(_response.type_name)
|
||
}
|
||
|
||
fn component_card_key(world: &World, entity: Entity, type_name: &str) -> String {
|
||
let actor_key = world
|
||
.get::<shared::ActorId>(entity)
|
||
.map(|id| id.0.as_str())
|
||
.filter(|id| !id.trim().is_empty())
|
||
.map(str::to_string)
|
||
.unwrap_or_else(|| format!("{entity:?}"));
|
||
format!("{actor_key}::{type_name}")
|
||
}
|
||
|
||
fn present_component_type_names(world: &World, entity: Entity) -> Vec<&'static str> {
|
||
if let Some(registry) = world.get_resource::<EditorComponentRegistry>() {
|
||
return registry
|
||
.descriptors
|
||
.iter()
|
||
.filter(|descriptor| {
|
||
!descriptor.hidden
|
||
&& registry.component_present(world, entity, descriptor.type_name)
|
||
})
|
||
.map(|descriptor| descriptor.type_name)
|
||
.collect();
|
||
}
|
||
let mut present = Vec::new();
|
||
if world.get::<AnimationControllerDesc>(entity).is_some() {
|
||
present.push(COMPONENT_ANIMATION_CONTROLLER_DESC);
|
||
}
|
||
if world.get::<StaticMeshRenderer>(entity).is_some() {
|
||
present.push(COMPONENT_STATIC_MESH_RENDERER);
|
||
}
|
||
if world.get::<SkinnedMeshRenderer>(entity).is_some() {
|
||
present.push(COMPONENT_SKINNED_MESH_RENDERER);
|
||
}
|
||
if world.get::<Primitive>(entity).is_some() {
|
||
present.push(COMPONENT_PRIMITIVE);
|
||
}
|
||
if world.get::<BrushDesc>(entity).is_some() {
|
||
present.push(COMPONENT_BRUSH_DESC);
|
||
}
|
||
if world.get::<MaterialDesc>(entity).is_some() || world.get::<Primitive>(entity).is_some() {
|
||
present.push(COMPONENT_MATERIAL_DESC);
|
||
}
|
||
if world.get::<LightDesc>(entity).is_some() {
|
||
present.push(COMPONENT_LIGHT_DESC);
|
||
}
|
||
if world.get::<AudioSourceDesc>(entity).is_some() {
|
||
present.push(COMPONENT_AUDIO_SOURCE_DESC);
|
||
}
|
||
if world.get::<AudioListenerDesc>(entity).is_some() {
|
||
present.push(COMPONENT_AUDIO_LISTENER_DESC);
|
||
}
|
||
if world.get::<RigidBodyDesc>(entity).is_some() {
|
||
present.push(COMPONENT_RIGID_BODY_DESC);
|
||
}
|
||
if world.get::<ColliderDesc>(entity).is_some() {
|
||
present.push(COMPONENT_COLLIDER_DESC);
|
||
}
|
||
if world.get::<PhysicsBody>(entity).is_some() {
|
||
present.push(COMPONENT_PHYSICS_BODY);
|
||
}
|
||
if world.get::<PlayerSpawn>(entity).is_some() {
|
||
present.push(COMPONENT_PLAYER_SPAWN);
|
||
}
|
||
if world.get::<WeaponSpawn>(entity).is_some() {
|
||
present.push(COMPONENT_WEAPON_SPAWN);
|
||
}
|
||
if world.get::<TriggerVolume>(entity).is_some() {
|
||
present.push(COMPONENT_TRIGGER_VOLUME);
|
||
}
|
||
if world.get::<TeamSpawn>(entity).is_some() {
|
||
present.push(COMPONENT_TEAM_SPAWN);
|
||
}
|
||
if world.get::<ObjectiveMarker>(entity).is_some() {
|
||
present.push(COMPONENT_OBJECTIVE_MARKER);
|
||
}
|
||
if world.get::<PrefabInstance>(entity).is_some() {
|
||
present.push(COMPONENT_PREFAB_INSTANCE);
|
||
}
|
||
if world.get::<PostProcessVolumeDesc>(entity).is_some() {
|
||
present.push(COMPONENT_POST_PROCESS_VOLUME);
|
||
}
|
||
if world.get::<ProjectSun>(entity).is_some() {
|
||
present.push(COMPONENT_PROJECT_SUN);
|
||
}
|
||
if world.get::<NavigationBounds>(entity).is_some() {
|
||
present.push(COMPONENT_NAVIGATION_BOUNDS);
|
||
}
|
||
if world.get::<NavigationObstacle>(entity).is_some() {
|
||
present.push(COMPONENT_NAVIGATION_OBSTACLE);
|
||
}
|
||
if world.get::<NavigationArea>(entity).is_some() {
|
||
present.push(COMPONENT_NAVIGATION_AREA);
|
||
}
|
||
if world.get::<NavigationLink>(entity).is_some() {
|
||
present.push(COMPONENT_NAVIGATION_LINK);
|
||
}
|
||
present
|
||
}
|
||
|
||
fn copy_component(world: &mut World, entity: Entity, type_name: &str) {
|
||
let descriptor = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.by_type_name(type_name)
|
||
.cloned();
|
||
if let Some(descriptor) = descriptor {
|
||
if let Ok(Some(value)) = crate::history::capture_reflected_component(
|
||
world,
|
||
entity,
|
||
descriptor.id,
|
||
descriptor.type_name,
|
||
) {
|
||
world.resource_mut::<InspectorClipboard>().component =
|
||
Some(CopiedComponent::Reflected(value));
|
||
return;
|
||
}
|
||
}
|
||
let component = match type_name {
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC => world
|
||
.get::<AnimationControllerDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::AnimationControllerDesc),
|
||
COMPONENT_PRIMITIVE => world
|
||
.get::<Primitive>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::Primitive),
|
||
COMPONENT_BRUSH_DESC => world
|
||
.get::<BrushDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::BrushDesc),
|
||
COMPONENT_STATIC_MESH_RENDERER => world
|
||
.get::<StaticMeshRenderer>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::StaticMeshRenderer),
|
||
COMPONENT_MATERIAL_DESC => world
|
||
.get::<MaterialDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::MaterialDesc),
|
||
COMPONENT_LIGHT_DESC => world
|
||
.get::<LightDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::LightDesc),
|
||
COMPONENT_AUDIO_SOURCE_DESC => world
|
||
.get::<AudioSourceDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::AudioSourceDesc),
|
||
COMPONENT_AUDIO_LISTENER_DESC => world
|
||
.get::<AudioListenerDesc>(entity)
|
||
.copied()
|
||
.map(CopiedComponent::AudioListenerDesc),
|
||
COMPONENT_RIGID_BODY_DESC => world
|
||
.get::<RigidBodyDesc>(entity)
|
||
.copied()
|
||
.map(CopiedComponent::RigidBodyDesc),
|
||
COMPONENT_COLLIDER_DESC => world
|
||
.get::<ColliderDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::ColliderDesc),
|
||
COMPONENT_PHYSICS_BODY => world
|
||
.get::<PhysicsBody>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::PhysicsBody),
|
||
COMPONENT_WEAPON_SPAWN => world
|
||
.get::<WeaponSpawn>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::WeaponSpawn),
|
||
COMPONENT_TRIGGER_VOLUME => world
|
||
.get::<TriggerVolume>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::TriggerVolume),
|
||
COMPONENT_TEAM_SPAWN => world
|
||
.get::<TeamSpawn>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::TeamSpawn),
|
||
COMPONENT_OBJECTIVE_MARKER => world
|
||
.get::<ObjectiveMarker>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::ObjectiveMarker),
|
||
COMPONENT_POST_PROCESS_VOLUME => world
|
||
.get::<PostProcessVolumeDesc>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::PostProcessVolume),
|
||
COMPONENT_PREFAB_INSTANCE => world
|
||
.get::<PrefabInstance>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::PrefabInstance),
|
||
COMPONENT_NAVIGATION_BOUNDS => world
|
||
.get::<NavigationBounds>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::NavigationBounds),
|
||
COMPONENT_NAVIGATION_OBSTACLE => world
|
||
.get::<NavigationObstacle>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::NavigationObstacle),
|
||
COMPONENT_NAVIGATION_AREA => world
|
||
.get::<NavigationArea>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::NavigationArea),
|
||
COMPONENT_NAVIGATION_LINK => world
|
||
.get::<NavigationLink>(entity)
|
||
.cloned()
|
||
.map(CopiedComponent::NavigationLink),
|
||
_ => None,
|
||
};
|
||
if let Some(component) = component {
|
||
world.resource_mut::<InspectorClipboard>().component = Some(component);
|
||
}
|
||
}
|
||
|
||
fn paste_component(world: &mut World, entity: Entity, type_name: &str) {
|
||
let component = world
|
||
.get_resource::<InspectorClipboard>()
|
||
.and_then(|clipboard| clipboard.component.clone());
|
||
if let Some(CopiedComponent::Reflected(value)) = component.as_ref() {
|
||
if value.type_path == type_name {
|
||
let value = value.clone();
|
||
let component_id = value.component_id.clone();
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Paste Component",
|
||
&component_id,
|
||
type_name,
|
||
move |world, entity| {
|
||
crate::history::apply_reflected_component(
|
||
world,
|
||
entity,
|
||
type_name,
|
||
Some(&value),
|
||
)
|
||
},
|
||
);
|
||
}
|
||
return;
|
||
}
|
||
match component {
|
||
Some(CopiedComponent::Reflected(_)) => {}
|
||
Some(CopiedComponent::AnimationControllerDesc(value))
|
||
if type_name == COMPONENT_ANIMATION_CONTROLLER_DESC =>
|
||
{
|
||
set_animation_controller_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::Primitive(value)) if type_name == COMPONENT_PRIMITIVE => {
|
||
set_primitive_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::BrushDesc(value)) if type_name == COMPONENT_BRUSH_DESC => {
|
||
set_brush_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::StaticMeshRenderer(value))
|
||
if type_name == COMPONENT_STATIC_MESH_RENDERER =>
|
||
{
|
||
set_static_mesh_renderer_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::MaterialDesc(value)) if type_name == COMPONENT_MATERIAL_DESC => {
|
||
set_material_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::LightDesc(value)) if type_name == COMPONENT_LIGHT_DESC => {
|
||
set_light_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::AudioSourceDesc(value))
|
||
if type_name == COMPONENT_AUDIO_SOURCE_DESC =>
|
||
{
|
||
set_audio_source_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::AudioListenerDesc(value))
|
||
if type_name == COMPONENT_AUDIO_LISTENER_DESC =>
|
||
{
|
||
set_audio_listener_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::RigidBodyDesc(value)) if type_name == COMPONENT_RIGID_BODY_DESC => {
|
||
set_rigid_body_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::ColliderDesc(value)) if type_name == COMPONENT_COLLIDER_DESC => {
|
||
set_collider_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::PhysicsBody(value)) if type_name == COMPONENT_PHYSICS_BODY => {
|
||
set_physics_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::PostProcessVolume(value))
|
||
if type_name == COMPONENT_POST_PROCESS_VOLUME =>
|
||
{
|
||
set_post_process_volume_with_history(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::WeaponSpawn(value)) if type_name == COMPONENT_WEAPON_SPAWN => {
|
||
insert_direct_component(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::TriggerVolume(value)) if type_name == COMPONENT_TRIGGER_VOLUME => {
|
||
insert_direct_component(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::TeamSpawn(value)) if type_name == COMPONENT_TEAM_SPAWN => {
|
||
insert_direct_component(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::ObjectiveMarker(value))
|
||
if type_name == COMPONENT_OBJECTIVE_MARKER =>
|
||
{
|
||
insert_direct_component(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::PrefabInstance(value)) if type_name == COMPONENT_PREFAB_INSTANCE => {
|
||
insert_direct_component(world, entity, value);
|
||
}
|
||
Some(CopiedComponent::NavigationBounds(mut value))
|
||
if type_name == COMPONENT_NAVIGATION_BOUNDS =>
|
||
{
|
||
value.artifact_path = world
|
||
.get::<NavigationBounds>(entity)
|
||
.map(|bounds| bounds.artifact_path.clone())
|
||
.unwrap_or_else(|| navigation_bounds_for_entity(world, entity).artifact_path);
|
||
crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
bounds: Some(value),
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
Some(CopiedComponent::NavigationObstacle(value))
|
||
if type_name == COMPONENT_NAVIGATION_OBSTACLE =>
|
||
{
|
||
crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
obstacle: Some(value),
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
Some(CopiedComponent::NavigationArea(value)) if type_name == COMPONENT_NAVIGATION_AREA => {
|
||
crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
area: Some(value),
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
Some(CopiedComponent::NavigationLink(value)) if type_name == COMPONENT_NAVIGATION_LINK => {
|
||
crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
link: Some(value),
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn reset_component(world: &mut World, entity: Entity, type_name: &str) {
|
||
let descriptor = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.by_type_name(type_name)
|
||
.cloned();
|
||
if let Some(descriptor) = descriptor {
|
||
let component_id = descriptor.id;
|
||
let type_path = descriptor.type_name;
|
||
if type_path == COMPONENT_ANIMATION_CONTROLLER_DESC {
|
||
let controller =
|
||
crate::ui::animation_inspector::default_controller_for_actor(world, entity);
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Reset Component",
|
||
component_id,
|
||
type_path,
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(controller);
|
||
Ok(())
|
||
},
|
||
);
|
||
} else if type_path == COMPONENT_NAVIGATION_BOUNDS {
|
||
let bounds = reset_navigation_bounds_for_entity(world, entity);
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Reset Component",
|
||
component_id,
|
||
type_path,
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(bounds);
|
||
Ok(())
|
||
},
|
||
);
|
||
} else {
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Reset Component",
|
||
component_id,
|
||
type_path,
|
||
move |world, entity| {
|
||
crate::history::apply_reflected_default(world, entity, type_path)
|
||
},
|
||
);
|
||
}
|
||
return;
|
||
}
|
||
match type_name {
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC => {
|
||
let controller =
|
||
crate::ui::animation_inspector::default_controller_for_actor(world, entity);
|
||
set_animation_controller_with_history(world, entity, controller);
|
||
}
|
||
COMPONENT_PRIMITIVE => set_primitive_with_history(world, entity, Primitive::default()),
|
||
COMPONENT_BRUSH_DESC => set_brush_with_history(world, entity, BrushDesc::default()),
|
||
COMPONENT_STATIC_MESH_RENDERER => {
|
||
set_static_mesh_renderer_with_history(world, entity, StaticMeshRenderer::default());
|
||
}
|
||
COMPONENT_MATERIAL_DESC => {
|
||
set_material_with_history(world, entity, MaterialDesc::default())
|
||
}
|
||
COMPONENT_LIGHT_DESC => set_light_with_history(world, entity, LightDesc::default()),
|
||
COMPONENT_AUDIO_SOURCE_DESC => {
|
||
set_audio_source_with_history(world, entity, AudioSourceDesc::default())
|
||
}
|
||
COMPONENT_AUDIO_LISTENER_DESC => {
|
||
set_audio_listener_with_history(world, entity, AudioListenerDesc::default())
|
||
}
|
||
COMPONENT_RIGID_BODY_DESC => {
|
||
set_rigid_body_with_history(world, entity, RigidBodyDesc::default());
|
||
}
|
||
COMPONENT_COLLIDER_DESC => {
|
||
set_collider_with_history(world, entity, ColliderDesc::default())
|
||
}
|
||
COMPONENT_PHYSICS_BODY => set_physics_with_history(world, entity, PhysicsBody::default()),
|
||
COMPONENT_POST_PROCESS_VOLUME => {
|
||
set_post_process_volume_with_history(world, entity, PostProcessVolumeDesc::default());
|
||
}
|
||
COMPONENT_NAVIGATION_BOUNDS => crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
bounds: Some(reset_navigation_bounds_for_entity(world, entity)),
|
||
..Default::default()
|
||
},
|
||
),
|
||
COMPONENT_NAVIGATION_OBSTACLE => crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
obstacle: Some(NavigationObstacle::default()),
|
||
..Default::default()
|
||
},
|
||
),
|
||
COMPONENT_NAVIGATION_AREA => crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
area: Some(NavigationArea::default()),
|
||
..Default::default()
|
||
},
|
||
),
|
||
COMPONENT_NAVIGATION_LINK => crate::history::set_navigation_with_history(
|
||
world,
|
||
entity,
|
||
crate::history::NavigationComponentState {
|
||
link: Some(NavigationLink::default()),
|
||
..Default::default()
|
||
},
|
||
),
|
||
COMPONENT_WEAPON_SPAWN => insert_direct_component(
|
||
world,
|
||
entity,
|
||
WeaponSpawn {
|
||
weapon_id: "rifle".into(),
|
||
},
|
||
),
|
||
COMPONENT_TRIGGER_VOLUME => {
|
||
insert_direct_component(world, entity, TriggerVolume::default())
|
||
}
|
||
COMPONENT_TEAM_SPAWN => insert_direct_component(world, entity, TeamSpawn { team_id: 0 }),
|
||
COMPONENT_OBJECTIVE_MARKER => insert_direct_component(
|
||
world,
|
||
entity,
|
||
ObjectiveMarker {
|
||
objective_id: "objective".into(),
|
||
},
|
||
),
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn insert_direct_component<T: Component>(world: &mut World, entity: Entity, component: T) {
|
||
if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
|
||
entity_mut.insert(component);
|
||
}
|
||
if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
|
||
scene_io.mark_dirty();
|
||
}
|
||
}
|
||
|
||
fn remove_registered_component(world: &mut World, entity: Entity, type_name: &str) {
|
||
let descriptor = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.by_type_name(type_name)
|
||
.cloned();
|
||
if let Some(descriptor) = descriptor {
|
||
if !descriptor.removable {
|
||
return;
|
||
}
|
||
let dependents = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.present_dependents(world, entity, descriptor.id)
|
||
.iter()
|
||
.map(|dependent| dependent.display_name)
|
||
.collect::<Vec<_>>();
|
||
if !dependents.is_empty() {
|
||
world
|
||
.resource_mut::<crate::scene_io::SceneIo>()
|
||
.set_status(format!(
|
||
"Remove blocked: required by {}. Remove dependent components first.",
|
||
dependents.join(", ")
|
||
));
|
||
return;
|
||
}
|
||
let result = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Remove Component",
|
||
descriptor.id,
|
||
descriptor.type_name,
|
||
|world, entity| {
|
||
crate::history::apply_reflected_component(world, entity, descriptor.type_name, None)
|
||
},
|
||
);
|
||
if result.is_ok() && type_name == COMPONENT_ANIMATION_CONTROLLER_DESC {
|
||
crate::ui::animation_inspector::stop_preview_if_actor(world, entity);
|
||
}
|
||
return;
|
||
}
|
||
let Some(before) = crate::history::snapshot_entity(world, entity) else {
|
||
return;
|
||
};
|
||
let removed_dedicated_audio_kind = matches!(
|
||
(type_name, before.actor_kind),
|
||
(COMPONENT_AUDIO_SOURCE_DESC, ActorKind::AudioSource)
|
||
| (COMPONENT_AUDIO_LISTENER_DESC, ActorKind::AudioListener)
|
||
);
|
||
let removed_dedicated_navigation_kind = before.actor_kind == ActorKind::Navigation
|
||
&& matches!(
|
||
type_name,
|
||
COMPONENT_NAVIGATION_BOUNDS
|
||
| COMPONENT_NAVIGATION_OBSTACLE
|
||
| COMPONENT_NAVIGATION_AREA
|
||
| COMPONENT_NAVIGATION_LINK
|
||
);
|
||
let removed_dedicated_skinned_kind =
|
||
type_name == COMPONENT_SKINNED_MESH_RENDERER && before.actor_kind == ActorKind::SkinnedMesh;
|
||
let removed = if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
|
||
match type_name {
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC if before.animation_controller.is_some() => {
|
||
entity_mut.remove::<AnimationControllerDesc>();
|
||
true
|
||
}
|
||
COMPONENT_PRIMITIVE if before.primitive.is_some() => {
|
||
entity_mut.remove::<Primitive>();
|
||
true
|
||
}
|
||
COMPONENT_BRUSH_DESC if before.brush.is_some() => {
|
||
entity_mut.remove::<BrushDesc>();
|
||
true
|
||
}
|
||
COMPONENT_STATIC_MESH_RENDERER if before.static_mesh_renderer.is_some() => {
|
||
entity_mut.remove::<StaticMeshRenderer>();
|
||
true
|
||
}
|
||
COMPONENT_SKINNED_MESH_RENDERER if before.skinned_mesh_renderer.is_some() => {
|
||
entity_mut.remove::<SkinnedMeshRenderer>();
|
||
true
|
||
}
|
||
COMPONENT_MATERIAL_DESC if before.material.is_some() => {
|
||
entity_mut.remove::<MaterialDesc>();
|
||
true
|
||
}
|
||
COMPONENT_LIGHT_DESC if before.light.is_some() => {
|
||
entity_mut.remove::<LightDesc>();
|
||
true
|
||
}
|
||
COMPONENT_AUDIO_SOURCE_DESC if before.audio_source.is_some() => {
|
||
entity_mut.remove::<AudioSourceDesc>();
|
||
true
|
||
}
|
||
COMPONENT_AUDIO_LISTENER_DESC if before.audio_listener.is_some() => {
|
||
entity_mut.remove::<AudioListenerDesc>();
|
||
true
|
||
}
|
||
COMPONENT_RIGID_BODY_DESC if before.rigid_body.is_some() => {
|
||
entity_mut.remove::<RigidBodyDesc>();
|
||
true
|
||
}
|
||
COMPONENT_COLLIDER_DESC if before.collider.is_some() => {
|
||
entity_mut.remove::<ColliderDesc>();
|
||
true
|
||
}
|
||
COMPONENT_PHYSICS_BODY if before.physics.is_some() => {
|
||
entity_mut.remove::<PhysicsBody>();
|
||
true
|
||
}
|
||
COMPONENT_PLAYER_SPAWN if before.player_spawn => {
|
||
entity_mut.remove::<PlayerSpawn>();
|
||
true
|
||
}
|
||
COMPONENT_WEAPON_SPAWN if before.weapon_spawn.is_some() => {
|
||
entity_mut.remove::<WeaponSpawn>();
|
||
true
|
||
}
|
||
COMPONENT_TRIGGER_VOLUME if before.trigger_volume.is_some() => {
|
||
entity_mut.remove::<TriggerVolume>();
|
||
true
|
||
}
|
||
COMPONENT_TEAM_SPAWN if before.team_spawn.is_some() => {
|
||
entity_mut.remove::<TeamSpawn>();
|
||
true
|
||
}
|
||
COMPONENT_OBJECTIVE_MARKER if before.objective.is_some() => {
|
||
entity_mut.remove::<ObjectiveMarker>();
|
||
true
|
||
}
|
||
COMPONENT_PREFAB_INSTANCE if before.prefab_instance.is_some() => {
|
||
entity_mut.remove::<PrefabInstance>();
|
||
true
|
||
}
|
||
COMPONENT_POST_PROCESS_VOLUME if before.post_process_volume.is_some() => {
|
||
entity_mut.remove::<PostProcessVolumeDesc>();
|
||
true
|
||
}
|
||
COMPONENT_NAVIGATION_BOUNDS if before.navigation_bounds.is_some() => {
|
||
entity_mut.remove::<NavigationBounds>();
|
||
true
|
||
}
|
||
COMPONENT_NAVIGATION_OBSTACLE if before.navigation_obstacle.is_some() => {
|
||
entity_mut.remove::<NavigationObstacle>();
|
||
true
|
||
}
|
||
COMPONENT_NAVIGATION_AREA if before.navigation_area.is_some() => {
|
||
entity_mut.remove::<NavigationArea>();
|
||
true
|
||
}
|
||
COMPONENT_NAVIGATION_LINK if before.navigation_link.is_some() => {
|
||
entity_mut.remove::<NavigationLink>();
|
||
true
|
||
}
|
||
_ => false,
|
||
}
|
||
} else {
|
||
false
|
||
};
|
||
if !removed {
|
||
return;
|
||
}
|
||
if type_name == COMPONENT_ANIMATION_CONTROLLER_DESC {
|
||
crate::ui::animation_inspector::stop_preview_if_actor(world, entity);
|
||
}
|
||
if removed_dedicated_audio_kind
|
||
|| removed_dedicated_navigation_kind
|
||
|| removed_dedicated_skinned_kind
|
||
{
|
||
let fallback = world
|
||
.get_entity(entity)
|
||
.ok()
|
||
.and_then(infer_actor_kind)
|
||
.unwrap_or(ActorKind::Empty);
|
||
if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
|
||
entity_mut.insert(fallback);
|
||
}
|
||
}
|
||
if let Some(after) = crate::history::snapshot_entity(world, entity) {
|
||
let snapshot = diff_added(&after, &before);
|
||
crate::history::push_command(
|
||
world,
|
||
crate::history::EditorCommand::RemoveComponent { entity, snapshot },
|
||
);
|
||
}
|
||
}
|
||
|
||
pub fn authoring_inspector_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
if !world
|
||
.get_entity(entity)
|
||
.is_ok_and(|entity_ref| entity_ref.contains::<LevelObject>())
|
||
{
|
||
return;
|
||
}
|
||
|
||
let present = present_component_type_names(world, entity);
|
||
let ordered = if let Some(order) = world.get::<InspectorOrder>(entity) {
|
||
world
|
||
.resource::<EditorComponentRegistry>()
|
||
.ordered_components(order, &present)
|
||
} else {
|
||
present
|
||
};
|
||
for type_name in ordered {
|
||
draw_authoring_component_by_type(world, ui, entity, type_name);
|
||
}
|
||
}
|
||
|
||
fn draw_authoring_component_by_type(
|
||
world: &mut World,
|
||
ui: &mut egui::Ui,
|
||
entity: Entity,
|
||
type_name: &'static str,
|
||
) {
|
||
if let Some(inspector) = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.inspector(type_name)
|
||
{
|
||
inspector(world, ui, entity);
|
||
return;
|
||
}
|
||
match type_name {
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC => {
|
||
crate::ui::animation_inspector::animation_controller_inspector_ui(world, ui, entity);
|
||
}
|
||
COMPONENT_STATIC_MESH_RENDERER => static_mesh_renderer_ui(world, ui, entity),
|
||
COMPONENT_SKINNED_MESH_RENDERER => skinned_mesh_renderer_ui(world, ui, entity),
|
||
COMPONENT_BRUSH_DESC => brush_editor_ui(world, ui, entity),
|
||
COMPONENT_TERRAIN_DESC => terrain_editor_ui(world, ui, entity),
|
||
COMPONENT_PRIMITIVE => primitive_editor_ui(world, ui, entity),
|
||
COMPONENT_MATERIAL_DESC => material_editor_ui(world, ui, entity),
|
||
COMPONENT_LIGHT_DESC => light_editor_ui(world, ui, entity),
|
||
COMPONENT_AUDIO_SOURCE_DESC => {
|
||
crate::ui::audio_inspector::audio_source_inspector_ui(world, ui, entity);
|
||
}
|
||
COMPONENT_AUDIO_LISTENER_DESC => {
|
||
crate::ui::audio_inspector::audio_listener_inspector_ui(world, ui, entity);
|
||
}
|
||
COMPONENT_RIGID_BODY_DESC => rigid_body_editor_ui(world, ui, entity),
|
||
COMPONENT_COLLIDER_DESC => collider_editor_ui(world, ui, entity),
|
||
COMPONENT_PHYSICS_BODY => physics_editor_ui(world, ui, entity),
|
||
COMPONENT_PLAYER_SPAWN => player_spawn_ui(world, ui, entity),
|
||
COMPONENT_WEAPON_SPAWN => weapon_spawn_ui(world, ui, entity),
|
||
COMPONENT_TRIGGER_VOLUME => trigger_volume_ui(world, ui, entity),
|
||
COMPONENT_TEAM_SPAWN => team_spawn_ui(world, ui, entity),
|
||
COMPONENT_OBJECTIVE_MARKER => objective_ui(world, ui, entity),
|
||
COMPONENT_PREFAB_INSTANCE => prefab_instance_ui(world, ui, entity),
|
||
COMPONENT_POST_PROCESS_VOLUME => {
|
||
crate::ui::post_process_volume_ui::post_process_volume_inspector_ui(world, ui, entity);
|
||
}
|
||
COMPONENT_PROJECT_SUN => project_sun_ui(world, ui, entity),
|
||
COMPONENT_NAVIGATION_BOUNDS => {
|
||
super::navigation_inspector::navigation_bounds_inspector_ui(world, ui, entity)
|
||
}
|
||
COMPONENT_NAVIGATION_OBSTACLE => {
|
||
super::navigation_inspector::navigation_obstacle_inspector_ui(world, ui, entity)
|
||
}
|
||
COMPONENT_NAVIGATION_AREA => {
|
||
super::navigation_inspector::navigation_area_inspector_ui(world, ui, entity)
|
||
}
|
||
COMPONENT_NAVIGATION_LINK => {
|
||
super::navigation_inspector::navigation_link_inspector_ui(world, ui, entity)
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
pub(crate) fn add_component_footer(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
ui.add_space(4.0);
|
||
let button_response = egui::Frame::new()
|
||
.fill(WIDGET_BG)
|
||
.stroke(egui::Stroke::new(1.0, BORDER))
|
||
.corner_radius(egui::CornerRadius::same(4))
|
||
.inner_margin(egui::Margin::symmetric(8, 6))
|
||
.show(ui, |ui| {
|
||
let open_for_entity = add_component_picker_open_for(world, entity);
|
||
let label = if open_for_entity {
|
||
"Close Add Component"
|
||
} else {
|
||
"+ Add Component"
|
||
};
|
||
if ui.button(label).clicked() {
|
||
if let Some(mut state) = world.get_resource_mut::<InspectorPanelState>() {
|
||
if open_for_entity {
|
||
state.add_component_open = false;
|
||
state.add_component_target = None;
|
||
} else {
|
||
state.add_component_open = true;
|
||
state.add_component_focus_search = true;
|
||
state.add_component_scroll_selected = true;
|
||
state.add_component_selected_index = 0;
|
||
state.add_component_target = Some(entity);
|
||
state.add_component_search.clear();
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
if add_component_picker_open_for(world, entity) {
|
||
add_component_picker_shelf(world, ui, entity, button_response.response.rect);
|
||
}
|
||
}
|
||
|
||
fn add_component_picker_open_for(world: &World, entity: Entity) -> bool {
|
||
world
|
||
.get_resource::<InspectorPanelState>()
|
||
.is_some_and(|state| state.add_component_open && state.add_component_target == Some(entity))
|
||
}
|
||
|
||
fn shelf_list_max_height(visible_space: f32) -> f32 {
|
||
(visible_space - 108.0).clamp(56.0, 320.0)
|
||
}
|
||
|
||
fn add_component_picker_shelf(
|
||
world: &mut World,
|
||
ui: &mut egui::Ui,
|
||
target: Entity,
|
||
anchor: egui::Rect,
|
||
) {
|
||
if world.get_entity(target).is_err() {
|
||
if let Some(mut state) = world.get_resource_mut::<InspectorPanelState>() {
|
||
state.add_component_open = false;
|
||
state.add_component_target = None;
|
||
}
|
||
return;
|
||
}
|
||
|
||
let descriptors = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.descriptors
|
||
.clone();
|
||
|
||
let visible = ui.clip_rect().intersect(ui.ctx().content_rect());
|
||
let space_above = (anchor.min.y - visible.top()).max(0.0);
|
||
let space_below = (visible.bottom() - anchor.max.y).max(0.0);
|
||
let direction = if space_below >= space_above {
|
||
AddComponentShelfDirection::Down
|
||
} else {
|
||
AddComponentShelfDirection::Up
|
||
};
|
||
let visible_space = match direction {
|
||
AddComponentShelfDirection::Up => space_above,
|
||
AddComponentShelfDirection::Down => space_below,
|
||
};
|
||
let list_max_height = shelf_list_max_height(visible_space);
|
||
let shelf_height = (list_max_height + 108.0).min((visible_space - 4.0).max(96.0));
|
||
let x = anchor
|
||
.min
|
||
.x
|
||
.clamp(visible.left(), visible.right() - anchor.width());
|
||
let y = match direction {
|
||
AddComponentShelfDirection::Up => anchor.min.y - shelf_height - 4.0,
|
||
AddComponentShelfDirection::Down => anchor.max.y + 4.0,
|
||
}
|
||
.clamp(
|
||
visible.top(),
|
||
(visible.bottom() - shelf_height).max(visible.top()),
|
||
);
|
||
let shelf_width = anchor.width().max(260.0).min(visible.width());
|
||
|
||
egui::Area::new(egui::Id::new(("add_component_shelf", target)))
|
||
.order(egui::Order::Foreground)
|
||
.fixed_pos(egui::pos2(x, y))
|
||
.show(ui.ctx(), |ui| {
|
||
ui.set_width(shelf_width);
|
||
add_component_picker_shelf_contents(world, ui, target, &descriptors, list_max_height);
|
||
});
|
||
}
|
||
|
||
fn add_component_picker_shelf_contents(
|
||
world: &mut World,
|
||
ui: &mut egui::Ui,
|
||
target: Entity,
|
||
descriptors: &[EditorComponentDescriptor],
|
||
list_max_height: f32,
|
||
) {
|
||
egui::Frame::new()
|
||
.fill(PANEL_BG_DARK)
|
||
.stroke(egui::Stroke::new(1.0, BORDER))
|
||
.corner_radius(egui::CornerRadius::same(4))
|
||
.inner_margin(egui::Margin::symmetric(8, 8))
|
||
.show(ui, |ui| {
|
||
ui.horizontal(|ui| {
|
||
ui.label(panel_heading("Add Component"));
|
||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||
if icon_button_small(ui, icons::X, "Close Add Component").clicked() {
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_open = false;
|
||
state.add_component_target = None;
|
||
}
|
||
});
|
||
});
|
||
ui.add_space(4.0);
|
||
|
||
let mut search_input = world
|
||
.resource::<InspectorPanelState>()
|
||
.add_component_search
|
||
.clone();
|
||
let search_response = ui.add(
|
||
egui::TextEdit::singleline(&mut search_input)
|
||
.hint_text("Search components...")
|
||
.desired_width(f32::INFINITY),
|
||
);
|
||
if search_response.changed() {
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_search = search_input.clone();
|
||
state.add_component_scroll_selected = true;
|
||
state.add_component_selected_index = 0;
|
||
}
|
||
if world
|
||
.resource::<InspectorPanelState>()
|
||
.add_component_focus_search
|
||
{
|
||
search_response.request_focus();
|
||
world
|
||
.resource_mut::<InspectorPanelState>()
|
||
.add_component_focus_search = false;
|
||
}
|
||
|
||
let search = search_input.to_lowercase();
|
||
let filtered = filtered_component_descriptors(descriptors, &search);
|
||
{
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
if !filtered.is_empty() {
|
||
state.add_component_selected_index =
|
||
state.add_component_selected_index.min(filtered.len() - 1);
|
||
} else {
|
||
state.add_component_selected_index = 0;
|
||
}
|
||
}
|
||
|
||
if ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::ArrowDown))
|
||
&& !filtered.is_empty()
|
||
{
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_selected_index =
|
||
(state.add_component_selected_index + 1) % filtered.len();
|
||
state.add_component_scroll_selected = true;
|
||
}
|
||
if ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::ArrowUp))
|
||
&& !filtered.is_empty()
|
||
{
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_selected_index = if state.add_component_selected_index == 0 {
|
||
filtered.len() - 1
|
||
} else {
|
||
state.add_component_selected_index - 1
|
||
};
|
||
state.add_component_scroll_selected = true;
|
||
}
|
||
if ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_open = false;
|
||
state.add_component_target = None;
|
||
}
|
||
if ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::Enter)) {
|
||
let selected_index = world
|
||
.resource::<InspectorPanelState>()
|
||
.add_component_selected_index;
|
||
if let Some(descriptor) = filtered.get(selected_index) {
|
||
let add_state = component_add_state(world, target, descriptor, descriptors);
|
||
if add_state.addable {
|
||
insert_registered_component(world, target, descriptor.type_name);
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_open = false;
|
||
state.add_component_target = None;
|
||
}
|
||
}
|
||
}
|
||
|
||
ui.separator();
|
||
if filtered.is_empty() {
|
||
ui.label(egui::RichText::new("No matching components").color(TEXT_DIM));
|
||
return;
|
||
}
|
||
|
||
egui::ScrollArea::vertical()
|
||
.max_height(list_max_height)
|
||
.show(ui, |ui| {
|
||
let (selected_index, scroll_selected) = {
|
||
let state = world.resource::<InspectorPanelState>();
|
||
(
|
||
state.add_component_selected_index,
|
||
state.add_component_scroll_selected,
|
||
)
|
||
};
|
||
let mut last_category = None;
|
||
for (index, descriptor) in filtered.iter().enumerate() {
|
||
if last_category != Some(descriptor.category) {
|
||
if last_category.is_some() {
|
||
ui.separator();
|
||
}
|
||
ui.label(panel_heading(component_category_label(descriptor.category)));
|
||
last_category = Some(descriptor.category);
|
||
}
|
||
|
||
let add_state = component_add_state(world, target, descriptor, descriptors);
|
||
let selected = index == selected_index;
|
||
let row = ui
|
||
.horizontal(|ui| {
|
||
ui.label(phosphor_icon_text(descriptor.icon, 14.0).color(TEXT_DIM));
|
||
ui.add_enabled(
|
||
add_state.addable,
|
||
egui::Button::selectable(selected, descriptor.display_name),
|
||
)
|
||
})
|
||
.inner
|
||
.on_hover_text(component_hover_text(descriptor, &add_state));
|
||
if selected && scroll_selected {
|
||
row.scroll_to_me(Some(egui::Align::Center));
|
||
}
|
||
if row.clicked() {
|
||
world
|
||
.resource_mut::<InspectorPanelState>()
|
||
.add_component_selected_index = index;
|
||
if add_state.addable {
|
||
insert_registered_component(world, target, descriptor.type_name);
|
||
let mut state = world.resource_mut::<InspectorPanelState>();
|
||
state.add_component_open = false;
|
||
state.add_component_target = None;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
world
|
||
.resource_mut::<InspectorPanelState>()
|
||
.add_component_scroll_selected = false;
|
||
});
|
||
}
|
||
|
||
fn filtered_component_descriptors<'a>(
|
||
descriptors: &'a [EditorComponentDescriptor],
|
||
search: &str,
|
||
) -> Vec<&'a EditorComponentDescriptor> {
|
||
[
|
||
EditorComponentCategory::Authoring,
|
||
EditorComponentCategory::Rendering,
|
||
EditorComponentCategory::Animation,
|
||
EditorComponentCategory::Audio,
|
||
EditorComponentCategory::Navigation,
|
||
EditorComponentCategory::Physics,
|
||
EditorComponentCategory::Gameplay,
|
||
EditorComponentCategory::Volumes,
|
||
]
|
||
.into_iter()
|
||
.flat_map(|category| {
|
||
descriptors.iter().filter(move |descriptor| {
|
||
descriptor.addable
|
||
&& !descriptor.hidden
|
||
&& descriptor.category == category
|
||
&& descriptor_matches_search(descriptor, search)
|
||
})
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn component_category_label(category: EditorComponentCategory) -> &'static str {
|
||
match category {
|
||
EditorComponentCategory::Authoring => "Authoring",
|
||
EditorComponentCategory::Rendering => "Rendering",
|
||
EditorComponentCategory::Animation => "Animation",
|
||
EditorComponentCategory::Audio => "Audio",
|
||
EditorComponentCategory::Navigation => "Navigation",
|
||
EditorComponentCategory::Physics => "Physics",
|
||
EditorComponentCategory::Gameplay => "Gameplay",
|
||
EditorComponentCategory::Volumes => "Volumes",
|
||
EditorComponentCategory::Editor => "Editor",
|
||
}
|
||
}
|
||
|
||
struct ComponentAddState {
|
||
addable: bool,
|
||
reason: Option<String>,
|
||
required: Vec<&'static str>,
|
||
recommended: Vec<&'static str>,
|
||
conflicts: Vec<&'static str>,
|
||
}
|
||
|
||
fn descriptor_matches_search(descriptor: &EditorComponentDescriptor, search: &str) -> bool {
|
||
search.trim().is_empty()
|
||
|| descriptor.display_name.to_lowercase().contains(search)
|
||
|| descriptor.type_name.to_lowercase().contains(search)
|
||
|| descriptor.description.to_lowercase().contains(search)
|
||
|| descriptor
|
||
.search_terms
|
||
.iter()
|
||
.any(|term| term.to_lowercase().contains(search))
|
||
}
|
||
|
||
fn component_add_state(
|
||
world: &World,
|
||
entity: Entity,
|
||
descriptor: &EditorComponentDescriptor,
|
||
descriptors: &[EditorComponentDescriptor],
|
||
) -> ComponentAddState {
|
||
let duplicate = component_present(world, entity, descriptor.type_name);
|
||
let conflicts = descriptor
|
||
.conflicts_with
|
||
.iter()
|
||
.copied()
|
||
.filter(|type_name| component_present(world, entity, type_name))
|
||
.collect::<Vec<_>>();
|
||
let recommended = descriptor
|
||
.recommended
|
||
.iter()
|
||
.copied()
|
||
.filter(|type_name| !component_present(world, entity, type_name))
|
||
.collect::<Vec<_>>();
|
||
let registry = world.resource::<EditorComponentRegistry>();
|
||
let required = registry
|
||
.required_component_ids(descriptor)
|
||
.iter()
|
||
.filter_map(|id| registry.by_id(id))
|
||
.filter(|required| !registry.component_present(world, entity, required.type_name))
|
||
.map(|required| required.display_name)
|
||
.collect::<Vec<_>>();
|
||
let reason = if duplicate {
|
||
Some("Already present on this actor.".to_string())
|
||
} else if !required.is_empty() {
|
||
Some(format!("Requires {}.", required.join(", ")))
|
||
} else if !conflicts.is_empty() {
|
||
Some(format!(
|
||
"Conflicts with {}.",
|
||
conflicts
|
||
.iter()
|
||
.map(|type_name| component_display_name(descriptors, type_name))
|
||
.collect::<Vec<_>>()
|
||
.join(", ")
|
||
))
|
||
} else {
|
||
None
|
||
};
|
||
ComponentAddState {
|
||
addable: reason.is_none(),
|
||
reason,
|
||
required,
|
||
recommended,
|
||
conflicts,
|
||
}
|
||
}
|
||
|
||
fn component_hover_text(
|
||
descriptor: &EditorComponentDescriptor,
|
||
state: &ComponentAddState,
|
||
) -> String {
|
||
let mut lines = vec![
|
||
descriptor.description.to_string(),
|
||
format!("Type: {}", descriptor.type_name),
|
||
format!("Hydration: {}", descriptor.hydration_effect),
|
||
format!(
|
||
"Inspector: removable={} reorderable={}",
|
||
descriptor.removable, descriptor.reorderable
|
||
),
|
||
];
|
||
if let Some(reason) = &state.reason {
|
||
lines.push(format!("Unavailable: {reason}"));
|
||
}
|
||
if !state.required.is_empty() {
|
||
lines.push(format!("Requires: {}", state.required.join(", ")));
|
||
}
|
||
if !state.recommended.is_empty() {
|
||
lines.push(format!(
|
||
"Recommended with: {}",
|
||
state.recommended.join(", ")
|
||
));
|
||
}
|
||
if !state.conflicts.is_empty() {
|
||
lines.push(format!("Conflicts: {}", state.conflicts.join(", ")));
|
||
}
|
||
lines.push(format!("Search: {}", descriptor.search_terms.join(", ")));
|
||
lines.join("\n")
|
||
}
|
||
|
||
fn component_display_name(
|
||
descriptors: &[EditorComponentDescriptor],
|
||
type_name: &str,
|
||
) -> &'static str {
|
||
descriptors
|
||
.iter()
|
||
.find(|descriptor| descriptor.type_name == type_name)
|
||
.map(|descriptor| descriptor.display_name)
|
||
.unwrap_or("component")
|
||
}
|
||
|
||
fn component_present(world: &World, entity: Entity, type_name: &str) -> bool {
|
||
if let Some(registry) = world.get_resource::<EditorComponentRegistry>() {
|
||
if registry.by_type_name(type_name).is_some() {
|
||
return registry.component_present(world, entity, type_name);
|
||
}
|
||
}
|
||
match type_name {
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC => {
|
||
world.get::<AnimationControllerDesc>(entity).is_some()
|
||
}
|
||
"shared::components::Primitive" => world.get::<Primitive>(entity).is_some(),
|
||
"shared::components::BrushDesc" => world.get::<BrushDesc>(entity).is_some(),
|
||
"shared::components::StaticMeshRenderer" => {
|
||
world.get::<StaticMeshRenderer>(entity).is_some()
|
||
}
|
||
COMPONENT_SKINNED_MESH_RENDERER => world.get::<SkinnedMeshRenderer>(entity).is_some(),
|
||
"shared::components::MaterialDesc" => world.get::<MaterialDesc>(entity).is_some(),
|
||
"shared::components::LightDesc" => world.get::<LightDesc>(entity).is_some(),
|
||
"shared::components::AudioSourceDesc" => world.get::<AudioSourceDesc>(entity).is_some(),
|
||
"shared::components::AudioListenerDesc" => world.get::<AudioListenerDesc>(entity).is_some(),
|
||
"shared::components::RigidBodyDesc" => world.get::<RigidBodyDesc>(entity).is_some(),
|
||
"shared::components::ColliderDesc" => world.get::<ColliderDesc>(entity).is_some(),
|
||
"shared::components::PlayerSpawn" => world.get::<PlayerSpawn>(entity).is_some(),
|
||
"shared::components::WeaponSpawn" => world.get::<WeaponSpawn>(entity).is_some(),
|
||
"shared::components::TriggerVolume" => world.get::<TriggerVolume>(entity).is_some(),
|
||
"shared::components::TeamSpawn" => world.get::<TeamSpawn>(entity).is_some(),
|
||
"shared::components::ObjectiveMarker" => world.get::<ObjectiveMarker>(entity).is_some(),
|
||
"shared::components::PostProcessVolumeDesc" => {
|
||
world.get::<PostProcessVolumeDesc>(entity).is_some()
|
||
}
|
||
COMPONENT_NAVIGATION_BOUNDS => world.get::<NavigationBounds>(entity).is_some(),
|
||
COMPONENT_NAVIGATION_OBSTACLE => world.get::<NavigationObstacle>(entity).is_some(),
|
||
COMPONENT_NAVIGATION_AREA => world.get::<NavigationArea>(entity).is_some(),
|
||
COMPONENT_NAVIGATION_LINK => world.get::<NavigationLink>(entity).is_some(),
|
||
_ => false,
|
||
}
|
||
}
|
||
|
||
fn insert_registered_component(world: &mut World, entity: Entity, type_name: &str) {
|
||
let descriptor = world
|
||
.resource::<EditorComponentRegistry>()
|
||
.by_type_name(type_name)
|
||
.cloned();
|
||
if let Some(descriptor) = descriptor {
|
||
if !descriptor.addable || component_present(world, entity, descriptor.type_name) {
|
||
return;
|
||
}
|
||
if descriptor.type_name == COMPONENT_ANIMATION_CONTROLLER_DESC {
|
||
let controller =
|
||
crate::ui::animation_inspector::default_controller_for_actor(world, entity);
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Add Component",
|
||
descriptor.id,
|
||
descriptor.type_name,
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(controller);
|
||
Ok(())
|
||
},
|
||
);
|
||
} else if descriptor.type_name == COMPONENT_NAVIGATION_BOUNDS {
|
||
let bounds = navigation_bounds_for_entity(world, entity);
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Add Component",
|
||
descriptor.id,
|
||
descriptor.type_name,
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(bounds);
|
||
Ok(())
|
||
},
|
||
);
|
||
} else {
|
||
let _ = crate::history::reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Add Component",
|
||
descriptor.id,
|
||
descriptor.type_name,
|
||
move |world, entity| {
|
||
crate::history::apply_reflected_default(world, entity, descriptor.type_name)
|
||
},
|
||
);
|
||
}
|
||
return;
|
||
}
|
||
match type_name {
|
||
COMPONENT_ANIMATION_CONTROLLER_DESC => {
|
||
let controller =
|
||
crate::ui::animation_inspector::default_controller_for_actor(world, entity);
|
||
insert_component(world, entity, move |world, e| {
|
||
world.entity_mut(e).insert(controller);
|
||
});
|
||
}
|
||
"shared::components::Primitive" => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((shared::ActorKind::StaticMesh, Primitive::cuboid(Vec3::ONE)));
|
||
}),
|
||
"shared::components::BrushDesc" => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((shared::ActorKind::Brush, BrushDesc::default()));
|
||
}),
|
||
"shared::components::StaticMeshRenderer" => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((shared::ActorKind::StaticMesh, StaticMeshRenderer::default()));
|
||
}),
|
||
"shared::components::MaterialDesc" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(MaterialDesc::default());
|
||
}),
|
||
"shared::components::LightDesc" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(LightDesc::default());
|
||
}),
|
||
"shared::components::AudioSourceDesc" => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((shared::ActorKind::AudioSource, AudioSourceDesc::default()));
|
||
}),
|
||
"shared::components::AudioListenerDesc" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert((
|
||
shared::ActorKind::AudioListener,
|
||
AudioListenerDesc::default(),
|
||
));
|
||
}),
|
||
"shared::components::RigidBodyDesc" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(RigidBodyDesc::default());
|
||
}),
|
||
"shared::components::ColliderDesc" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(ColliderDesc::default());
|
||
}),
|
||
"shared::components::PlayerSpawn" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(PlayerSpawn);
|
||
}),
|
||
"shared::components::WeaponSpawn" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(WeaponSpawn {
|
||
weapon_id: "rifle".into(),
|
||
});
|
||
}),
|
||
"shared::components::TriggerVolume" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(TriggerVolume::default());
|
||
}),
|
||
"shared::components::TeamSpawn" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(TeamSpawn { team_id: 0 });
|
||
}),
|
||
"shared::components::ObjectiveMarker" => insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(ObjectiveMarker {
|
||
objective_id: "objective".into(),
|
||
});
|
||
}),
|
||
COMPONENT_NAVIGATION_BOUNDS => insert_component(world, entity, |world, e| {
|
||
let bounds = navigation_bounds_for_entity(world, e);
|
||
world.entity_mut(e).insert((ActorKind::Navigation, bounds));
|
||
}),
|
||
COMPONENT_NAVIGATION_OBSTACLE => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((ActorKind::Navigation, NavigationObstacle::default()));
|
||
}),
|
||
COMPONENT_NAVIGATION_AREA => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((ActorKind::Navigation, NavigationArea::default()));
|
||
}),
|
||
COMPONENT_NAVIGATION_LINK => insert_component(world, entity, |world, e| {
|
||
world
|
||
.entity_mut(e)
|
||
.insert((ActorKind::Navigation, NavigationLink::default()));
|
||
}),
|
||
"shared::components::PostProcessVolumeDesc" => {
|
||
insert_component(world, entity, |world, e| {
|
||
world.entity_mut(e).insert(PostProcessVolumeDesc::default());
|
||
})
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn navigation_bounds_for_entity(world: &World, entity: Entity) -> NavigationBounds {
|
||
world
|
||
.get::<ActorId>(entity)
|
||
.map(|actor_id| NavigationBounds::for_actor(&actor_id.0))
|
||
.unwrap_or_else(|| NavigationBounds::for_actor(&uuid::Uuid::new_v4().to_string()))
|
||
}
|
||
|
||
fn reset_navigation_bounds_for_entity(world: &World, entity: Entity) -> NavigationBounds {
|
||
let mut bounds = navigation_bounds_for_entity(world, entity);
|
||
if let Some(current) = world.get::<NavigationBounds>(entity) {
|
||
bounds.artifact_path.clone_from(¤t.artifact_path);
|
||
}
|
||
bounds
|
||
}
|
||
|
||
fn insert_component(world: &mut World, entity: Entity, insert: impl FnOnce(&mut World, Entity)) {
|
||
let before = crate::history::snapshot_entity(world, entity);
|
||
let old_kind = before.as_ref().map(|s| s.actor_kind);
|
||
insert(world, entity);
|
||
let after = crate::history::snapshot_entity(world, entity);
|
||
if let (Some(before), Some(after)) = (before, after) {
|
||
if let Some(old) = old_kind {
|
||
if old != after.actor_kind {
|
||
crate::history::set_actor_kind_with_history(world, entity, old, after.actor_kind);
|
||
}
|
||
}
|
||
crate::history::push_command(
|
||
world,
|
||
crate::history::EditorCommand::AddComponent {
|
||
entity,
|
||
snapshot: diff_added(&before, &after),
|
||
},
|
||
);
|
||
}
|
||
}
|
||
|
||
fn diff_added(before: &EditorEntitySnapshot, after: &EditorEntitySnapshot) -> EditorEntitySnapshot {
|
||
EditorEntitySnapshot {
|
||
actor_id: None,
|
||
actor_kind: after.actor_kind,
|
||
actor_name: None,
|
||
name: None,
|
||
transform: after.transform,
|
||
primitive: after
|
||
.primitive
|
||
.clone()
|
||
.filter(|_| before.primitive.is_none()),
|
||
brush: after.brush.clone().filter(|_| before.brush.is_none()),
|
||
static_mesh_renderer: after
|
||
.static_mesh_renderer
|
||
.clone()
|
||
.filter(|_| before.static_mesh_renderer.is_none()),
|
||
skinned_mesh_renderer: after
|
||
.skinned_mesh_renderer
|
||
.clone()
|
||
.filter(|_| before.skinned_mesh_renderer.is_none()),
|
||
material: after.material.clone().filter(|_| before.material.is_none()),
|
||
material_override: after
|
||
.material_override
|
||
.clone()
|
||
.filter(|_| before.material_override.is_none()),
|
||
rigid_body: after.rigid_body.filter(|_| before.rigid_body.is_none()),
|
||
collider: after.collider.clone().filter(|_| before.collider.is_none()),
|
||
physics: after.physics.clone().filter(|_| before.physics.is_none()),
|
||
light: after.light.clone().filter(|_| before.light.is_none()),
|
||
animation_controller: after
|
||
.animation_controller
|
||
.clone()
|
||
.filter(|_| before.animation_controller.is_none()),
|
||
audio_source: after
|
||
.audio_source
|
||
.clone()
|
||
.filter(|_| before.audio_source.is_none()),
|
||
audio_listener: after
|
||
.audio_listener
|
||
.filter(|_| before.audio_listener.is_none()),
|
||
player_spawn: after.player_spawn && !before.player_spawn,
|
||
model: after.model.clone().filter(|_| before.model.is_none()),
|
||
prefab: after.prefab.clone().filter(|_| before.prefab.is_none()),
|
||
prefab_instance: after
|
||
.prefab_instance
|
||
.clone()
|
||
.filter(|_| before.prefab_instance.is_none()),
|
||
weapon_spawn: after
|
||
.weapon_spawn
|
||
.clone()
|
||
.filter(|_| before.weapon_spawn.is_none()),
|
||
trigger_volume: after
|
||
.trigger_volume
|
||
.clone()
|
||
.filter(|_| before.trigger_volume.is_none()),
|
||
post_process_volume: after
|
||
.post_process_volume
|
||
.clone()
|
||
.filter(|_| before.post_process_volume.is_none()),
|
||
team_spawn: after
|
||
.team_spawn
|
||
.clone()
|
||
.filter(|_| before.team_spawn.is_none()),
|
||
objective: after
|
||
.objective
|
||
.clone()
|
||
.filter(|_| before.objective.is_none()),
|
||
navigation_bounds: after
|
||
.navigation_bounds
|
||
.clone()
|
||
.filter(|_| before.navigation_bounds.is_none()),
|
||
navigation_obstacle: after
|
||
.navigation_obstacle
|
||
.clone()
|
||
.filter(|_| before.navigation_obstacle.is_none()),
|
||
navigation_area: after
|
||
.navigation_area
|
||
.clone()
|
||
.filter(|_| before.navigation_area.is_none()),
|
||
navigation_link: after
|
||
.navigation_link
|
||
.clone()
|
||
.filter(|_| before.navigation_link.is_none()),
|
||
hierarchy_sibling_index: after.hierarchy_sibling_index,
|
||
editor_visibility: after.editor_visibility,
|
||
inspector_order: None,
|
||
component_states: None,
|
||
children: Vec::new(),
|
||
}
|
||
}
|
||
|
||
fn static_mesh_asset_ref_candidates(
|
||
world: &mut World,
|
||
kind: AssetRefCandidateKind,
|
||
) -> Vec<AssetRefCandidate> {
|
||
let thumbnail_by_path = model_thumbnail_texture_by_path(world);
|
||
let Some(registry) = world.get_resource::<AssetRegistry>() else {
|
||
return Vec::new();
|
||
};
|
||
let catalog = world.get_resource::<EditorAssets>();
|
||
let mut seen = HashSet::new();
|
||
let mut candidates = Vec::new();
|
||
|
||
for record in ®istry.records {
|
||
let Some(manifest_path) = record.import_settings.static_mesh_manifest_path.as_deref()
|
||
else {
|
||
continue;
|
||
};
|
||
let Ok(manifest) = load_static_mesh_manifest(manifest_path) else {
|
||
continue;
|
||
};
|
||
let selection = AssetSelection::File(manifest.source.path.clone());
|
||
let texture_id = thumbnail_by_path.get(&manifest.source.path).copied();
|
||
let folder_path = catalog
|
||
.and_then(|assets| {
|
||
assets
|
||
.assets
|
||
.iter()
|
||
.find(|asset| asset.path.as_deref() == Some(manifest.source.path.as_str()))
|
||
.map(|asset| asset.folder_path.clone())
|
||
})
|
||
.unwrap_or_else(|| fallback_asset_folder(&manifest.source.path));
|
||
|
||
for part in &manifest.parts {
|
||
let source_material_ref = source_material_ref_for_part(&manifest.asset_id, part);
|
||
let candidate = match kind {
|
||
AssetRefCandidateKind::Mesh => {
|
||
let sub_asset_id = if part.id.trim().is_empty() {
|
||
part_id_from_label(&part.mesh_label)
|
||
} else {
|
||
part.id.clone()
|
||
};
|
||
AssetRefCandidate {
|
||
reference: EditorAssetRef::new(
|
||
manifest.asset_id.clone(),
|
||
sub_asset_id,
|
||
part.name.clone(),
|
||
),
|
||
label: part.name.clone(),
|
||
detail: format!("{} | {}", manifest.label, manifest.source.path),
|
||
selection: selection.clone(),
|
||
folder_path: folder_path.clone(),
|
||
texture_id,
|
||
}
|
||
}
|
||
AssetRefCandidateKind::Material => {
|
||
let Some(material_ref) = source_material_ref else {
|
||
continue;
|
||
};
|
||
AssetRefCandidate {
|
||
reference: material_ref,
|
||
label: part.material_slot_name.clone(),
|
||
detail: format!("{} | {}", manifest.label, manifest.source.path),
|
||
selection: selection.clone(),
|
||
folder_path: folder_path.clone(),
|
||
texture_id: None,
|
||
}
|
||
}
|
||
AssetRefCandidateKind::Texture => continue,
|
||
};
|
||
|
||
let key = (
|
||
candidate.reference.asset_id.clone(),
|
||
candidate.reference.sub_asset_id.clone(),
|
||
);
|
||
if seen.insert(key) {
|
||
candidates.push(candidate);
|
||
}
|
||
}
|
||
}
|
||
|
||
candidates.sort_by(|a, b| a.detail.cmp(&b.detail).then(a.label.cmp(&b.label)));
|
||
candidates
|
||
}
|
||
|
||
fn texture_asset_candidates(world: &World) -> Vec<TextureAssetCandidate> {
|
||
let Some(catalog) = world.get_resource::<EditorAssets>() else {
|
||
return Vec::new();
|
||
};
|
||
let snapshot = world
|
||
.get_resource::<AssetThumbnailCache>()
|
||
.map(AssetThumbnailCache::snapshot);
|
||
let mut candidates: Vec<_> = catalog
|
||
.assets
|
||
.iter()
|
||
.filter(|asset| matches!(asset.kind, EditorAssetKind::Texture))
|
||
.filter_map(|asset| {
|
||
let path = asset.path.clone()?;
|
||
let texture_id = snapshot
|
||
.as_ref()
|
||
.and_then(|snapshot| snapshot.texture_for(asset));
|
||
Some(TextureAssetCandidate {
|
||
label: asset.label.clone(),
|
||
path: path.clone(),
|
||
folder_path: asset.folder_path.clone(),
|
||
selection: AssetSelection::File(path),
|
||
texture_id,
|
||
})
|
||
})
|
||
.collect();
|
||
candidates.sort_by(|a, b| a.label.cmp(&b.label).then(a.path.cmp(&b.path)));
|
||
candidates
|
||
}
|
||
|
||
fn texture_asset_ref_candidates(world: &World) -> Vec<AssetRefCandidate> {
|
||
let Some(catalog) = world.get_resource::<EditorAssets>() else {
|
||
return Vec::new();
|
||
};
|
||
let Some(registry) = world.get_resource::<AssetRegistry>() else {
|
||
return Vec::new();
|
||
};
|
||
let snapshot = world
|
||
.get_resource::<AssetThumbnailCache>()
|
||
.map(AssetThumbnailCache::snapshot);
|
||
let mut candidates: Vec<_> = catalog
|
||
.assets
|
||
.iter()
|
||
.filter(|asset| matches!(asset.kind, EditorAssetKind::Texture))
|
||
.filter_map(|asset| {
|
||
let path = asset.path.as_deref()?;
|
||
let record = find_asset_by_path(registry, path)?;
|
||
Some(AssetRefCandidate {
|
||
reference: EditorAssetRef::new(
|
||
record.id.as_string(),
|
||
"texture:source",
|
||
asset.label.clone(),
|
||
)
|
||
.with_source_path(path),
|
||
label: asset.label.clone(),
|
||
detail: path.to_string(),
|
||
selection: AssetSelection::File(path.to_string()),
|
||
folder_path: asset.folder_path.clone(),
|
||
texture_id: snapshot
|
||
.as_ref()
|
||
.and_then(|snapshot| snapshot.texture_for(asset)),
|
||
})
|
||
})
|
||
.collect();
|
||
candidates.sort_by(|a, b| a.label.cmp(&b.label).then(a.detail.cmp(&b.detail)));
|
||
candidates
|
||
}
|
||
|
||
fn brush_face_material_ref_candidates(world: &mut World) -> Vec<AssetRefCandidate> {
|
||
let mut candidates = static_mesh_asset_ref_candidates(world, AssetRefCandidateKind::Material);
|
||
let Some(catalog) = world.get_resource::<EditorAssets>() else {
|
||
return candidates;
|
||
};
|
||
let Some(registry) = world.get_resource::<AssetRegistry>() else {
|
||
return candidates;
|
||
};
|
||
let mut seen: HashSet<_> = candidates
|
||
.iter()
|
||
.map(|candidate| {
|
||
(
|
||
candidate.reference.asset_id.clone(),
|
||
candidate.reference.sub_asset_id.clone(),
|
||
)
|
||
})
|
||
.collect();
|
||
for asset in catalog
|
||
.assets
|
||
.iter()
|
||
.filter(|asset| matches!(asset.kind, EditorAssetKind::Material))
|
||
{
|
||
let Some(path) = asset.path.as_deref() else {
|
||
continue;
|
||
};
|
||
let Some(record) = find_asset_by_path(registry, path) else {
|
||
continue;
|
||
};
|
||
let sub_asset_id = if shared::MaterialInstanceAsset::load_from_path(path).is_ok() {
|
||
"material:instance"
|
||
} else {
|
||
"material:source"
|
||
};
|
||
let reference = EditorAssetRef::new(record.id.as_string(), sub_asset_id, &asset.label)
|
||
.with_source_path(path);
|
||
let key = (reference.asset_id.clone(), reference.sub_asset_id.clone());
|
||
if !seen.insert(key) {
|
||
continue;
|
||
}
|
||
candidates.push(AssetRefCandidate {
|
||
reference,
|
||
label: asset.label.clone(),
|
||
detail: path.to_string(),
|
||
selection: AssetSelection::File(path.to_string()),
|
||
folder_path: asset.folder_path.clone(),
|
||
texture_id: None,
|
||
});
|
||
}
|
||
candidates.sort_by(|a, b| a.label.cmp(&b.label).then(a.detail.cmp(&b.detail)));
|
||
candidates
|
||
}
|
||
|
||
fn asset_ref_candidate_from_selection(
|
||
world: &World,
|
||
selection: &AssetSelection,
|
||
kind: AssetRefCandidateKind,
|
||
) -> Option<AssetRefCandidate> {
|
||
let registry = world.get_resource::<AssetRegistry>()?;
|
||
match (kind, selection) {
|
||
(AssetRefCandidateKind::Material, AssetSelection::File(path)) => {
|
||
let asset = world
|
||
.get_resource::<EditorAssets>()?
|
||
.assets
|
||
.iter()
|
||
.find(|asset| {
|
||
matches!(asset.kind, EditorAssetKind::Material)
|
||
&& asset.path.as_deref() == Some(path.as_str())
|
||
})?;
|
||
let record = find_asset_by_path(registry, path)?;
|
||
let sub_asset_id = if shared::MaterialInstanceAsset::load_from_path(path).is_ok() {
|
||
"material:instance"
|
||
} else {
|
||
"material:source"
|
||
};
|
||
Some(AssetRefCandidate {
|
||
reference: EditorAssetRef::new(
|
||
record.id.as_string(),
|
||
sub_asset_id,
|
||
asset.label.clone(),
|
||
)
|
||
.with_source_path(path),
|
||
label: asset.label.clone(),
|
||
detail: path.clone(),
|
||
selection: selection.clone(),
|
||
folder_path: asset.folder_path.clone(),
|
||
texture_id: None,
|
||
})
|
||
}
|
||
(AssetRefCandidateKind::Texture, AssetSelection::File(path)) => {
|
||
let asset = world
|
||
.get_resource::<EditorAssets>()?
|
||
.assets
|
||
.iter()
|
||
.find(|asset| {
|
||
matches!(asset.kind, EditorAssetKind::Texture)
|
||
&& asset.path.as_deref() == Some(path.as_str())
|
||
})?;
|
||
let record = find_asset_by_path(registry, path)?;
|
||
Some(AssetRefCandidate {
|
||
reference: EditorAssetRef::new(
|
||
record.id.as_string(),
|
||
"texture:source",
|
||
asset.label.clone(),
|
||
)
|
||
.with_source_path(path),
|
||
label: asset.label.clone(),
|
||
detail: path.clone(),
|
||
selection: selection.clone(),
|
||
folder_path: asset.folder_path.clone(),
|
||
texture_id: None,
|
||
})
|
||
}
|
||
(
|
||
AssetRefCandidateKind::Material,
|
||
AssetSelection::SubAsset {
|
||
parent_path,
|
||
sub_asset_id,
|
||
label,
|
||
kind: AssetSubAssetKind::Material,
|
||
..
|
||
},
|
||
) => {
|
||
let record = find_asset_by_path(registry, parent_path)?;
|
||
Some(AssetRefCandidate {
|
||
reference: EditorAssetRef::new(
|
||
record.id.as_string(),
|
||
sub_asset_id.clone(),
|
||
label.clone(),
|
||
),
|
||
label: label.clone(),
|
||
detail: parent_path.clone(),
|
||
selection: selection.clone(),
|
||
folder_path: fallback_asset_folder(parent_path),
|
||
texture_id: None,
|
||
})
|
||
}
|
||
(
|
||
AssetRefCandidateKind::Texture,
|
||
AssetSelection::SubAsset {
|
||
parent_path,
|
||
sub_asset_id,
|
||
label,
|
||
kind: AssetSubAssetKind::Texture,
|
||
source_path,
|
||
},
|
||
) => {
|
||
let record = find_asset_by_path(registry, parent_path)?;
|
||
Some(AssetRefCandidate {
|
||
reference: EditorAssetRef::new(
|
||
record.id.as_string(),
|
||
sub_asset_id.clone(),
|
||
label.clone(),
|
||
)
|
||
.with_source_path(source_path.clone().unwrap_or_else(|| parent_path.clone())),
|
||
label: label.clone(),
|
||
detail: source_path.clone().unwrap_or_else(|| parent_path.clone()),
|
||
selection: selection.clone(),
|
||
folder_path: fallback_asset_folder(parent_path),
|
||
texture_id: None,
|
||
})
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
fn request_texture_asset_thumbnails(world: &mut World) {
|
||
let requests: Vec<_> = world
|
||
.get_resource::<EditorAssets>()
|
||
.map(|assets| {
|
||
assets
|
||
.assets
|
||
.iter()
|
||
.filter(|asset| matches!(asset.kind, EditorAssetKind::Texture))
|
||
.filter_map(|asset| Some((asset_cache_key(asset), asset.path.clone()?)))
|
||
.collect()
|
||
})
|
||
.unwrap_or_default();
|
||
if requests.is_empty() || world.get_resource::<AssetThumbnailCache>().is_none() {
|
||
return;
|
||
}
|
||
let asset_server = world.resource::<AssetServer>().clone();
|
||
world.resource_scope(|_world, mut cache: Mut<AssetThumbnailCache>| {
|
||
for (key, path) in requests {
|
||
cache.request_texture(key, path, &asset_server);
|
||
}
|
||
});
|
||
}
|
||
|
||
fn texture_path_from_selection(
|
||
world: &World,
|
||
selection: &AssetSelection,
|
||
) -> Option<TextureAssetCandidate> {
|
||
match selection {
|
||
AssetSelection::File(path) => {
|
||
let asset = world
|
||
.get_resource::<EditorAssets>()?
|
||
.assets
|
||
.iter()
|
||
.find(|asset| {
|
||
matches!(asset.kind, EditorAssetKind::Texture)
|
||
&& asset.path.as_deref() == Some(path.as_str())
|
||
})?;
|
||
Some(TextureAssetCandidate {
|
||
label: asset.label.clone(),
|
||
path: path.clone(),
|
||
folder_path: asset.folder_path.clone(),
|
||
selection: selection.clone(),
|
||
texture_id: None,
|
||
})
|
||
}
|
||
AssetSelection::SubAsset {
|
||
label,
|
||
kind: AssetSubAssetKind::Texture,
|
||
source_path: Some(path),
|
||
..
|
||
} => {
|
||
if let Some(asset) = world.get_resource::<EditorAssets>().and_then(|assets| {
|
||
assets
|
||
.assets
|
||
.iter()
|
||
.find(|asset| asset.path.as_deref() == Some(path.as_str()))
|
||
}) {
|
||
return Some(TextureAssetCandidate {
|
||
label: asset.label.clone(),
|
||
path: path.clone(),
|
||
folder_path: asset.folder_path.clone(),
|
||
selection: selection.clone(),
|
||
texture_id: None,
|
||
});
|
||
}
|
||
Some(TextureAssetCandidate {
|
||
label: label.clone(),
|
||
path: path.clone(),
|
||
folder_path: fallback_asset_folder(path),
|
||
selection: selection.clone(),
|
||
texture_id: None,
|
||
})
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
fn source_material_ref_for_part(
|
||
asset_id: &str,
|
||
part: &crate::assets::static_mesh::StaticMeshPart,
|
||
) -> Option<EditorAssetRef> {
|
||
let material_label = part.material_label.as_deref()?;
|
||
let sub_asset_id = part
|
||
.material_id
|
||
.clone()
|
||
.filter(|id| !id.trim().is_empty())
|
||
.unwrap_or_else(|| material_id_from_label(material_label));
|
||
Some(EditorAssetRef::new(
|
||
asset_id.to_string(),
|
||
sub_asset_id,
|
||
part.material_slot_name.clone(),
|
||
))
|
||
}
|
||
|
||
fn model_thumbnail_texture_by_path(world: &mut World) -> HashMap<String, egui::TextureId> {
|
||
let model_assets: Vec<EditorAsset> = world
|
||
.get_resource::<EditorAssets>()
|
||
.map(|assets| {
|
||
assets
|
||
.assets
|
||
.iter()
|
||
.filter(|asset| matches!(asset.kind, EditorAssetKind::Model))
|
||
.cloned()
|
||
.collect()
|
||
})
|
||
.unwrap_or_default();
|
||
if model_assets.is_empty() {
|
||
return HashMap::new();
|
||
}
|
||
if world.get_resource::<AssetThumbnailCache>().is_none() {
|
||
return HashMap::new();
|
||
}
|
||
|
||
let asset_server = world.resource::<AssetServer>().clone();
|
||
world.resource_scope(|world, mut cache: Mut<AssetThumbnailCache>| {
|
||
if let Some(mut studio) = world.get_resource_mut::<ThumbnailStudio>() {
|
||
for asset in &model_assets {
|
||
let Some(path) = asset.path.as_ref() else {
|
||
continue;
|
||
};
|
||
cache.request_model(
|
||
asset_cache_key(asset),
|
||
path.clone(),
|
||
&asset_server,
|
||
&mut studio,
|
||
);
|
||
}
|
||
}
|
||
});
|
||
|
||
let snapshot = world.resource::<AssetThumbnailCache>().snapshot();
|
||
model_assets
|
||
.iter()
|
||
.filter_map(|asset| {
|
||
Some((
|
||
asset.path.clone()?,
|
||
snapshot.texture_ids.get(&asset_cache_key(asset)).copied()?,
|
||
))
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn fallback_asset_folder(path: &str) -> String {
|
||
Path::new(path)
|
||
.parent()
|
||
.and_then(|parent| parent.to_str())
|
||
.filter(|folder| !folder.trim().is_empty())
|
||
.unwrap_or(crate::assets::ASSETS_ROOT)
|
||
.replace('\\', "/")
|
||
}
|
||
|
||
fn locate_asset_ref(
|
||
world: &mut World,
|
||
asset: Option<&EditorAssetRef>,
|
||
candidates: &[AssetRefCandidate],
|
||
) {
|
||
let Some(asset) = asset.filter(|asset| asset.is_resolved()) else {
|
||
return;
|
||
};
|
||
let Some(candidate) = candidates.iter().find(|candidate| {
|
||
candidate.reference.asset_id == asset.asset_id
|
||
&& candidate.reference.sub_asset_id == asset.sub_asset_id
|
||
}) else {
|
||
if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
|
||
scene_io.status = format!("Could not locate imported asset {}", asset.label);
|
||
}
|
||
return;
|
||
};
|
||
|
||
if let Some(mut assets) = world.get_resource_mut::<EditorAssets>() {
|
||
assets.current_folder = candidate.folder_path.clone();
|
||
assets.select(candidate.selection.clone());
|
||
}
|
||
if let Some(mut ui_state) = world.get_resource_mut::<UiState>() {
|
||
let panel_nodes = ui_state.panel_nodes;
|
||
open_and_focus_tab(
|
||
&mut ui_state.dock_state,
|
||
EditorTab::AssetBrowser,
|
||
&panel_nodes,
|
||
);
|
||
}
|
||
}
|
||
|
||
fn skinned_mesh_renderer_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let material_candidates = brush_face_material_ref_candidates(world);
|
||
let Some(mut renderer) = world.get::<SkinnedMeshRenderer>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let original = renderer.clone();
|
||
let mut changed = false;
|
||
let mut options = ComponentCardOptions::removable(
|
||
COMPONENT_SKINNED_MESH_RENDERER,
|
||
"Skinned Mesh Renderer",
|
||
icons::PERSON_SIMPLE_RUN,
|
||
);
|
||
options.active_toggle = false;
|
||
options.removable = world.get::<AnimationControllerDesc>(entity).is_none();
|
||
options.resettable = false;
|
||
options.copyable = false;
|
||
let context = component_card_context(world, entity, options);
|
||
let response = component_card(ui, &context, |ui| {
|
||
property_row(ui, "Source", |ui| {
|
||
ui.add(
|
||
egui::Label::new(if renderer.path.trim().is_empty() {
|
||
"Unassigned"
|
||
} else {
|
||
renderer.path.as_str()
|
||
})
|
||
.truncate(),
|
||
);
|
||
});
|
||
property_row(ui, "Scene", |ui| {
|
||
ui.label(renderer.scene_index.to_string());
|
||
});
|
||
property_row(ui, "Asset ID", |ui| {
|
||
ui.add(
|
||
egui::Label::new(if renderer.asset_id.trim().is_empty() {
|
||
"Legacy/path-only"
|
||
} else {
|
||
renderer.asset_id.as_str()
|
||
})
|
||
.truncate(),
|
||
);
|
||
});
|
||
ui.label(
|
||
egui::RichText::new(
|
||
"Preserves the imported skeleton hierarchy and Bevy skinned-mesh bindings.",
|
||
)
|
||
.small()
|
||
.color(TEXT_DIM),
|
||
);
|
||
ui.add_space(8.0);
|
||
ui.label(egui::RichText::new("Material slots").strong());
|
||
if renderer.materials.slots.is_empty() {
|
||
ui.label(
|
||
egui::RichText::new("No imported slots; reimport the source model")
|
||
.small()
|
||
.color(TEXT_DIM),
|
||
);
|
||
}
|
||
for slot in &mut renderer.materials.slots {
|
||
slot_card(ui, |ui| {
|
||
ui.label(egui::RichText::new(&slot.name).strong());
|
||
let response = asset_selector_row(
|
||
ui,
|
||
"Material",
|
||
icons::PALETTE,
|
||
slot.material.as_ref().map(|reference| &reference.0),
|
||
slot.source_material.as_ref().map(|reference| &reference.0),
|
||
true,
|
||
&material_candidates,
|
||
None,
|
||
);
|
||
if let Some(selected) = response.selected {
|
||
slot.material = Some(MaterialRef::new(selected));
|
||
changed = true;
|
||
}
|
||
if response.clear {
|
||
slot.material = None;
|
||
changed = true;
|
||
}
|
||
if response.locate {
|
||
let reference = slot
|
||
.material
|
||
.as_ref()
|
||
.or(slot.source_material.as_ref())
|
||
.map(|reference| &reference.0);
|
||
locate_asset_ref(world, reference, &material_candidates);
|
||
}
|
||
ui.label(
|
||
egui::RichText::new(format!("ID: {}", slot.id.0))
|
||
.small()
|
||
.color(TEXT_DIM),
|
||
);
|
||
});
|
||
}
|
||
for orphan in &renderer.materials.orphaned_assignments {
|
||
ui.label(
|
||
egui::RichText::new(format!(
|
||
"Orphaned: {} ({})",
|
||
orphan.last_known_name, orphan.slot_id.0
|
||
))
|
||
.small()
|
||
.color(egui::Color32::YELLOW),
|
||
);
|
||
}
|
||
if world.get::<AnimationControllerDesc>(entity).is_some() {
|
||
ui.label(
|
||
egui::RichText::new(
|
||
"Remove the Animation Controller before removing its renderer.",
|
||
)
|
||
.small()
|
||
.color(TEXT_MUTED),
|
||
);
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, response);
|
||
if changed && renderer != original {
|
||
let result = reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Assign Skinned Material Slot",
|
||
shared::AUTHORING_COMPONENT_SKINNED_MESH_RENDERER,
|
||
COMPONENT_SKINNED_MESH_RENDERER,
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(renderer);
|
||
Ok(())
|
||
},
|
||
);
|
||
if let Err(error) = result {
|
||
world.resource_mut::<crate::scene_io::SceneIo>().status = error;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn static_mesh_renderer_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let mesh_candidates = static_mesh_asset_ref_candidates(world, AssetRefCandidateKind::Mesh);
|
||
let material_candidates = brush_face_material_ref_candidates(world);
|
||
let Some(mut renderer) = world.get::<StaticMeshRenderer>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let original = renderer.clone();
|
||
let mut changed = false;
|
||
let mut remove_entry = None;
|
||
for index in 0..renderer.slots.len() {
|
||
ensure_slot_id(&mut renderer.slots[index], index);
|
||
let part = &renderer.slots[index];
|
||
if renderer.materials.slot(&part.material_slot_id).is_none() {
|
||
renderer.materials.slots.push(shared::RendererMaterialSlot {
|
||
id: part.material_slot_id.clone(),
|
||
name: part.name.clone(),
|
||
source_material: part.material.clone().map(MaterialRef::new),
|
||
material: None,
|
||
});
|
||
}
|
||
}
|
||
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(
|
||
COMPONENT_STATIC_MESH_RENDERER,
|
||
"Static Mesh Renderer",
|
||
icons::CUBE,
|
||
),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
if renderer.slots.is_empty() {
|
||
ui.label(egui::RichText::new("No renderer slots").color(TEXT_DIM));
|
||
}
|
||
|
||
for (index, entry) in renderer.slots.iter_mut().enumerate() {
|
||
ensure_slot_id(entry, index);
|
||
let material_slot_name = renderer
|
||
.materials
|
||
.slot(&entry.material_slot_id)
|
||
.map(|slot| slot.name.clone())
|
||
.unwrap_or_else(|| "Missing slot".into());
|
||
let thumbnail = thumbnail_for_mesh(&entry.mesh, &mesh_candidates);
|
||
|
||
slot_card(ui, |ui| {
|
||
slot_header(ui, index, &entry.name, |ui| {
|
||
status_dot(ui, egui::Color32::from_rgb(74, 181, 104), "Slot active");
|
||
if icon_button_small(ui, icons::TRASH, "Remove slot").clicked() {
|
||
remove_entry = Some(index);
|
||
}
|
||
ui.label(phosphor_icon(icons::DOTS_THREE_VERTICAL, 16.0).color(TEXT_DIM));
|
||
});
|
||
ui.add_space(6.0);
|
||
|
||
let mut draw_fields = |ui: &mut egui::Ui, entry: &mut StaticMeshRendererEntry| {
|
||
property_row(ui, "Name", |ui| {
|
||
changed |= ui
|
||
.add_sized(
|
||
[text_field_width(ui), 20.0],
|
||
egui::TextEdit::singleline(&mut entry.name),
|
||
)
|
||
.changed();
|
||
});
|
||
let mesh_response = asset_selector_row(
|
||
ui,
|
||
"Mesh",
|
||
icons::CUBE,
|
||
Some(&entry.mesh),
|
||
None,
|
||
false,
|
||
&mesh_candidates,
|
||
None,
|
||
);
|
||
if let Some(selected) = mesh_response.selected {
|
||
entry.mesh = selected;
|
||
changed = true;
|
||
}
|
||
if mesh_response.locate {
|
||
locate_asset_ref(world, Some(&entry.mesh), &mesh_candidates);
|
||
}
|
||
|
||
property_row(ui, "Material slot", |ui| {
|
||
ui.label(&material_slot_name);
|
||
});
|
||
ui.horizontal_wrapped(|ui| {
|
||
changed |= ui.checkbox(&mut entry.visible, "Visible").changed();
|
||
changed |= ui
|
||
.checkbox(&mut entry.cast_shadows, "Cast shadows")
|
||
.changed();
|
||
changed |= ui
|
||
.checkbox(&mut entry.receive_shadows, "Receive shadows")
|
||
.changed();
|
||
});
|
||
};
|
||
|
||
if ui.available_width() < 430.0 {
|
||
slot_thumbnail(ui, thumbnail);
|
||
ui.add_space(6.0);
|
||
draw_fields(ui, entry);
|
||
} else {
|
||
ui.horizontal(|ui| {
|
||
slot_thumbnail(ui, thumbnail);
|
||
ui.add_space(10.0);
|
||
ui.vertical(|ui| {
|
||
ui.set_max_width(ui.available_width());
|
||
draw_fields(ui, entry);
|
||
});
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
ui.add_space(8.0);
|
||
ui.label(egui::RichText::new("Material slots").strong());
|
||
for slot in &mut renderer.materials.slots {
|
||
slot_card(ui, |ui| {
|
||
ui.label(egui::RichText::new(&slot.name).strong());
|
||
let response = asset_selector_row(
|
||
ui,
|
||
"Material",
|
||
icons::PALETTE,
|
||
slot.material.as_ref().map(|reference| &reference.0),
|
||
slot.source_material.as_ref().map(|reference| &reference.0),
|
||
true,
|
||
&material_candidates,
|
||
None,
|
||
);
|
||
if let Some(selected) = response.selected {
|
||
slot.material = Some(MaterialRef::new(selected));
|
||
changed = true;
|
||
}
|
||
if response.clear {
|
||
slot.material = None;
|
||
changed = true;
|
||
}
|
||
if response.locate {
|
||
let reference = slot
|
||
.material
|
||
.as_ref()
|
||
.or(slot.source_material.as_ref())
|
||
.map(|reference| &reference.0);
|
||
locate_asset_ref(world, reference, &material_candidates);
|
||
}
|
||
ui.label(
|
||
egui::RichText::new(format!("ID: {}", slot.id.0))
|
||
.small()
|
||
.color(TEXT_DIM),
|
||
);
|
||
});
|
||
}
|
||
|
||
let add_slot = ui
|
||
.add_sized(
|
||
[ui.available_width().max(1.0), 28.0],
|
||
egui::Button::new("+ Add Slot").fill(ELEVATED_BG.linear_multiply(0.45)),
|
||
)
|
||
.clicked();
|
||
if add_slot {
|
||
let index = renderer.slots.len();
|
||
let entry = StaticMeshRendererEntry {
|
||
id: ComponentInstanceId::new(format!("slot:{index}")),
|
||
material_slot_id: ComponentInstanceId::new(format!("slot:manual:{index}")),
|
||
..Default::default()
|
||
};
|
||
renderer.materials.slots.push(shared::RendererMaterialSlot {
|
||
id: entry.material_slot_id.clone(),
|
||
name: format!("Material {index}"),
|
||
source_material: None,
|
||
material: None,
|
||
});
|
||
renderer.slots.push(entry);
|
||
changed = true;
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
|
||
if let Some(index) = remove_entry {
|
||
let removed = renderer.slots.remove(index);
|
||
if let Some(slot_index) = renderer
|
||
.materials
|
||
.slots
|
||
.iter()
|
||
.position(|slot| slot.id == removed.material_slot_id)
|
||
{
|
||
let slot = renderer.materials.slots.remove(slot_index);
|
||
if let Some(material) = slot.material {
|
||
renderer
|
||
.materials
|
||
.orphaned_assignments
|
||
.push(shared::OrphanedMaterialAssignment {
|
||
slot_id: slot.id,
|
||
last_known_name: slot.name,
|
||
material,
|
||
});
|
||
}
|
||
}
|
||
changed = true;
|
||
}
|
||
if changed && renderer != original {
|
||
set_static_mesh_renderer_with_history(world, entity, renderer);
|
||
}
|
||
}
|
||
|
||
fn ensure_slot_id(entry: &mut StaticMeshRendererEntry, index: usize) {
|
||
if entry.id.is_empty() {
|
||
entry.id = ComponentInstanceId::new(format!("slot:{index}"));
|
||
}
|
||
if entry.material_slot_id.is_empty() {
|
||
entry.material_slot_id = ComponentInstanceId::new(format!("slot:{}", entry.id.0));
|
||
}
|
||
}
|
||
|
||
fn slot_card(ui: &mut egui::Ui, add_contents: impl FnOnce(&mut egui::Ui)) {
|
||
egui::Frame::new()
|
||
.fill(WIDGET_BG.linear_multiply(0.82))
|
||
.stroke(egui::Stroke::new(1.0, BORDER))
|
||
.corner_radius(egui::CornerRadius::same(4))
|
||
.inner_margin(egui::Margin::symmetric(8, 8))
|
||
.show(ui, |ui| {
|
||
ui.set_max_width(ui.available_width());
|
||
add_contents(ui);
|
||
});
|
||
ui.add_space(4.0);
|
||
}
|
||
|
||
fn slot_header(
|
||
ui: &mut egui::Ui,
|
||
index: usize,
|
||
slot_name: &str,
|
||
add_actions: impl FnOnce(&mut egui::Ui),
|
||
) {
|
||
ui.horizontal(|ui| {
|
||
ui.label(phosphor_icon(icons::CARET_DOWN, 13.0).color(TEXT_DIM));
|
||
ui.label(format!("Slot {index}"));
|
||
let badge = if slot_name.trim().is_empty() {
|
||
"Mesh"
|
||
} else {
|
||
slot_name.trim()
|
||
};
|
||
ui.add(
|
||
egui::Button::new(
|
||
egui::RichText::new(badge).color(egui::Color32::from_rgb(153, 202, 255)),
|
||
)
|
||
.fill(SELECTION_BG_MUTED)
|
||
.stroke(egui::Stroke::new(1.0, SELECTION_BG_MUTED))
|
||
.corner_radius(4.0),
|
||
);
|
||
ui.with_layout(
|
||
egui::Layout::right_to_left(egui::Align::Center),
|
||
add_actions,
|
||
);
|
||
});
|
||
}
|
||
|
||
fn status_dot(ui: &mut egui::Ui, color: egui::Color32, tooltip: &str) {
|
||
let (rect, response) = ui.allocate_exact_size(egui::vec2(18.0, 20.0), egui::Sense::hover());
|
||
ui.painter().circle_filled(rect.center(), 4.0, color);
|
||
response.on_hover_text(tooltip);
|
||
}
|
||
|
||
fn status_dot_button(ui: &mut egui::Ui, color: egui::Color32, tooltip: &str) -> egui::Response {
|
||
let (rect, response) = ui.allocate_exact_size(egui::vec2(18.0, 20.0), egui::Sense::click());
|
||
let color = if response.hovered() {
|
||
color.linear_multiply(1.2)
|
||
} else {
|
||
color
|
||
};
|
||
ui.painter().circle_filled(rect.center(), 4.0, color);
|
||
response.on_hover_text(tooltip)
|
||
}
|
||
|
||
fn slot_thumbnail(ui: &mut egui::Ui, texture_id: Option<egui::TextureId>) {
|
||
let size = 86.0_f32.min(ui.available_width().max(1.0));
|
||
let (rect, _response) = ui.allocate_exact_size(egui::vec2(size, size), egui::Sense::hover());
|
||
ui.painter().rect(
|
||
rect,
|
||
4.0,
|
||
PANEL_BG_DARK,
|
||
egui::Stroke::new(1.0, BORDER),
|
||
egui::StrokeKind::Inside,
|
||
);
|
||
if let Some(texture_id) = texture_id {
|
||
let uv = egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0));
|
||
ui.painter()
|
||
.image(texture_id, rect.shrink(6.0), uv, egui::Color32::WHITE);
|
||
} else {
|
||
ui.painter().text(
|
||
rect.center(),
|
||
egui::Align2::CENTER_CENTER,
|
||
icons::CUBE.as_str(),
|
||
egui::FontId::new(28.0, egui::FontFamily::Name("phosphor-regular".into())),
|
||
TEXT_MUTED,
|
||
);
|
||
}
|
||
}
|
||
|
||
fn thumbnail_for_mesh(
|
||
mesh: &EditorAssetRef,
|
||
candidates: &[AssetRefCandidate],
|
||
) -> Option<egui::TextureId> {
|
||
candidates
|
||
.iter()
|
||
.find(|candidate| {
|
||
candidate.reference.asset_id == mesh.asset_id
|
||
&& candidate.reference.sub_asset_id == mesh.sub_asset_id
|
||
})
|
||
.and_then(|candidate| candidate.texture_id)
|
||
}
|
||
|
||
#[expect(
|
||
clippy::too_many_arguments,
|
||
reason = "asset selector rows keep immediate-mode UI inputs explicit"
|
||
)]
|
||
fn asset_selector_row(
|
||
ui: &mut egui::Ui,
|
||
label: &str,
|
||
icon: Icon,
|
||
asset: Option<&EditorAssetRef>,
|
||
inherited_asset: Option<&EditorAssetRef>,
|
||
clearable: bool,
|
||
candidates: &[AssetRefCandidate],
|
||
drop_candidate: Option<&AssetRefCandidate>,
|
||
) -> AssetSelectorResponse {
|
||
let mut response = AssetSelectorResponse::default();
|
||
if ui.available_width() < COMPACT_INSPECTOR_WIDTH {
|
||
ui.vertical(|ui| {
|
||
ui.label(label);
|
||
let control_width = ui.available_width().max(1.0);
|
||
asset_selector_control(
|
||
ui,
|
||
icon,
|
||
asset,
|
||
inherited_asset,
|
||
clearable,
|
||
control_width,
|
||
candidates,
|
||
drop_candidate,
|
||
&mut response,
|
||
);
|
||
});
|
||
} else {
|
||
ui.horizontal(|ui| {
|
||
let row_width = ui.available_width().max(1.0);
|
||
let label_width = ASSET_SELECTOR_LABEL_WIDTH.min(row_width);
|
||
let control_width = (row_width - label_width - ui.spacing().item_spacing.x).max(1.0);
|
||
ui.add_sized([label_width, 20.0], egui::Label::new(label));
|
||
asset_selector_control(
|
||
ui,
|
||
icon,
|
||
asset,
|
||
inherited_asset,
|
||
clearable,
|
||
control_width,
|
||
candidates,
|
||
drop_candidate,
|
||
&mut response,
|
||
);
|
||
});
|
||
}
|
||
response
|
||
}
|
||
|
||
#[expect(
|
||
clippy::too_many_arguments,
|
||
reason = "asset selector controls keep immediate-mode UI inputs explicit"
|
||
)]
|
||
fn asset_selector_control(
|
||
ui: &mut egui::Ui,
|
||
icon: Icon,
|
||
asset: Option<&EditorAssetRef>,
|
||
inherited_asset: Option<&EditorAssetRef>,
|
||
clearable: bool,
|
||
control_width: f32,
|
||
candidates: &[AssetRefCandidate],
|
||
drop_candidate: Option<&AssetRefCandidate>,
|
||
response: &mut AssetSelectorResponse,
|
||
) {
|
||
let display_asset = asset.or(inherited_asset);
|
||
let inherited = asset.is_none() && inherited_asset.is_some();
|
||
let selector_width = control_width.min(ui.available_width()).max(1.0);
|
||
exact_region(
|
||
ui,
|
||
egui::vec2(selector_width, ASSET_SELECTOR_HEIGHT),
|
||
egui::Layout::top_down(egui::Align::Min),
|
||
|ui| {
|
||
ui.set_clip_rect(ui.max_rect());
|
||
let rect = ui.max_rect();
|
||
let valid_drag = drop_candidate.is_some();
|
||
let drop_hovered = valid_drag && ui.rect_contains_pointer(rect);
|
||
let stroke = if drop_hovered {
|
||
egui::Stroke::new(2.0, egui::Color32::from_rgb(125, 198, 255))
|
||
} else if valid_drag {
|
||
egui::Stroke::new(1.0, egui::Color32::from_rgb(58, 88, 122))
|
||
} else {
|
||
egui::Stroke::new(1.0, BORDER)
|
||
};
|
||
let fill = if drop_hovered {
|
||
egui::Color32::from_rgb(29, 57, 86)
|
||
} else {
|
||
WIDGET_BG.linear_multiply(0.75)
|
||
};
|
||
let inner_width = (selector_width - 18.0).max(1.0);
|
||
egui::Frame::new()
|
||
.fill(fill)
|
||
.stroke(stroke)
|
||
.corner_radius(egui::CornerRadius::same(4))
|
||
.inner_margin(egui::Margin::symmetric(8, 6))
|
||
.show(ui, |ui| {
|
||
ui.set_width(inner_width);
|
||
ui.horizontal(|ui| {
|
||
ui.add_sized(
|
||
[18.0, 20.0],
|
||
egui::Label::new(phosphor_icon(icon, 14.0).color(TEXT_DIM)),
|
||
);
|
||
let action_width = if clearable { 78.0 } else { 52.0 };
|
||
let text_width = (ui.available_width() - action_width)
|
||
.max(1.0)
|
||
.min(ui.available_width().max(1.0));
|
||
ui.vertical(|ui| {
|
||
ui.set_max_width(text_width);
|
||
let name = display_asset
|
||
.map(|asset| asset.label.as_str())
|
||
.filter(|label| !label.trim().is_empty())
|
||
.unwrap_or("(none)");
|
||
ui.add(egui::Label::new(name).truncate());
|
||
let id = display_asset
|
||
.map(|asset| {
|
||
if inherited {
|
||
format!("Source default | {}", asset.sub_asset_id)
|
||
} else {
|
||
asset.sub_asset_id.clone()
|
||
}
|
||
})
|
||
.filter(|id| !id.trim().is_empty())
|
||
.unwrap_or_else(|| "No imported asset selected".to_string());
|
||
ui.add(
|
||
egui::Label::new(egui::RichText::new(id).color(TEXT_DIM))
|
||
.truncate(),
|
||
);
|
||
});
|
||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||
if clearable {
|
||
let clear = ui.add_enabled(
|
||
asset.is_some(),
|
||
egui::Button::new(phosphor_icon(icons::X, 16.0))
|
||
.frame(false)
|
||
.min_size(egui::vec2(22.0, 22.0)),
|
||
);
|
||
if clear.on_hover_text("Clear actor override").clicked() {
|
||
response.clear = true;
|
||
}
|
||
}
|
||
let locate = ui.add_enabled(
|
||
display_asset.is_some_and(EditorAssetRef::is_resolved),
|
||
egui::Button::new(phosphor_icon(icons::CROSSHAIR, 16.0))
|
||
.frame(false)
|
||
.min_size(egui::vec2(22.0, 22.0)),
|
||
);
|
||
if locate.on_hover_text("Locate in content browser").clicked() {
|
||
response.locate = true;
|
||
}
|
||
if candidates.is_empty() {
|
||
ui.add_enabled(
|
||
false,
|
||
egui::Button::new(phosphor_icon(icons::FOLDER_OPEN, 16.0))
|
||
.frame(false)
|
||
.min_size(egui::vec2(22.0, 22.0)),
|
||
)
|
||
.on_hover_text("No imported assets available");
|
||
} else {
|
||
let menu =
|
||
ui.menu_button(phosphor_icon(icons::FOLDER_OPEN, 16.0), |ui| {
|
||
ui.set_min_width(220.0);
|
||
for candidate in candidates {
|
||
let selected = display_asset
|
||
.is_some_and(|asset| asset == &candidate.reference);
|
||
let clicked = ui
|
||
.selectable_label(
|
||
selected,
|
||
candidate.label.as_str(),
|
||
)
|
||
.on_hover_text(candidate.detail.as_str())
|
||
.clicked();
|
||
if clicked {
|
||
response.selected =
|
||
Some(candidate.reference.clone());
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
menu.response.on_hover_text("Browse assets");
|
||
}
|
||
});
|
||
});
|
||
});
|
||
if drop_hovered && ui.input(|input| input.pointer.any_released()) {
|
||
if let Some(candidate) = drop_candidate {
|
||
response.selected = Some(candidate.reference.clone());
|
||
response.accepted_drop = true;
|
||
}
|
||
}
|
||
},
|
||
);
|
||
}
|
||
|
||
fn material_shader_ui(ui: &mut egui::Ui, material: &mut MaterialDesc) -> bool {
|
||
let mut changed = false;
|
||
property_row(ui, "Shader", |ui| {
|
||
egui::ComboBox::from_id_salt("material_shader_kind")
|
||
.selected_text(match material.shader.kind {
|
||
MaterialShaderKind::StandardLit => "Standard Lit",
|
||
MaterialShaderKind::Unlit => "Unlit",
|
||
MaterialShaderKind::Custom => "Custom",
|
||
})
|
||
.show_ui(ui, |ui| {
|
||
changed |= ui
|
||
.selectable_value(
|
||
&mut material.shader.kind,
|
||
MaterialShaderKind::StandardLit,
|
||
"Standard Lit",
|
||
)
|
||
.changed();
|
||
changed |= ui
|
||
.selectable_value(
|
||
&mut material.shader.kind,
|
||
MaterialShaderKind::Unlit,
|
||
"Unlit",
|
||
)
|
||
.changed();
|
||
changed |= ui
|
||
.selectable_value(
|
||
&mut material.shader.kind,
|
||
MaterialShaderKind::Custom,
|
||
"Custom",
|
||
)
|
||
.changed();
|
||
});
|
||
});
|
||
if matches!(material.shader.kind, MaterialShaderKind::Custom) {
|
||
changed |= option_string_ui(ui, "Shader schema", &mut material.shader.schema_path);
|
||
changed |= option_string_ui(ui, "WGSL shader", &mut material.shader.shader_path);
|
||
}
|
||
if !material.parameters.is_empty() {
|
||
ui.label(panel_heading("Shader Parameters"));
|
||
for parameter in &mut material.parameters {
|
||
changed |= material_parameter_ui(ui, parameter);
|
||
}
|
||
}
|
||
changed
|
||
}
|
||
|
||
fn material_parameter_ui(ui: &mut egui::Ui, parameter: &mut MaterialParameter) -> bool {
|
||
ui.horizontal_wrapped(|ui| {
|
||
ui.label(¶meter.name);
|
||
match &mut parameter.value {
|
||
MaterialParameterValue::Bool(value) => ui.checkbox(value, "").changed(),
|
||
MaterialParameterValue::Float(value) => ui
|
||
.add_sized(
|
||
[fit_width(ui, 64.0, 120.0), 20.0],
|
||
egui::DragValue::new(value)
|
||
.speed(0.01)
|
||
.min_decimals(2)
|
||
.max_decimals(4),
|
||
)
|
||
.changed(),
|
||
MaterialParameterValue::Vec2(value) => {
|
||
let mut changed = false;
|
||
changed |= ui
|
||
.add_sized(
|
||
[fit_width(ui, 52.0, 88.0), 20.0],
|
||
egui::DragValue::new(&mut value.x).speed(0.01),
|
||
)
|
||
.changed();
|
||
changed |= ui
|
||
.add_sized(
|
||
[fit_width(ui, 52.0, 88.0), 20.0],
|
||
egui::DragValue::new(&mut value.y).speed(0.01),
|
||
)
|
||
.changed();
|
||
changed
|
||
}
|
||
MaterialParameterValue::Vec3(value) => {
|
||
let mut changed = false;
|
||
changed |= ui
|
||
.add_sized(
|
||
[fit_width(ui, 52.0, 88.0), 20.0],
|
||
egui::DragValue::new(&mut value.x).speed(0.01),
|
||
)
|
||
.changed();
|
||
changed |= ui
|
||
.add_sized(
|
||
[fit_width(ui, 52.0, 88.0), 20.0],
|
||
egui::DragValue::new(&mut value.y).speed(0.01),
|
||
)
|
||
.changed();
|
||
changed |= ui
|
||
.add_sized(
|
||
[fit_width(ui, 52.0, 88.0), 20.0],
|
||
egui::DragValue::new(&mut value.z).speed(0.01),
|
||
)
|
||
.changed();
|
||
changed
|
||
}
|
||
MaterialParameterValue::Color(value) => {
|
||
let mut rgba = [value.r, value.g, value.b, value.a];
|
||
let changed = ui.color_edit_button_rgba_unmultiplied(&mut rgba).changed();
|
||
if changed {
|
||
*value = ColorDesc {
|
||
r: rgba[0],
|
||
g: rgba[1],
|
||
b: rgba[2],
|
||
a: rgba[3],
|
||
};
|
||
}
|
||
changed
|
||
}
|
||
MaterialParameterValue::Enum(value) => ui
|
||
.add_sized(
|
||
[
|
||
fit_width(ui, MIN_INLINE_CONTROL_WIDTH, TEXT_FIELD_MAX_WIDTH),
|
||
20.0,
|
||
],
|
||
egui::TextEdit::singleline(value),
|
||
)
|
||
.changed(),
|
||
}
|
||
})
|
||
.inner
|
||
}
|
||
|
||
pub(crate) fn component_card(
|
||
ui: &mut egui::Ui,
|
||
context: &ComponentCardContext,
|
||
add_contents: impl FnOnce(&mut egui::Ui),
|
||
) -> ComponentCardResponse {
|
||
let mut response = ComponentCardResponse {
|
||
type_name: context.options.type_name,
|
||
..Default::default()
|
||
};
|
||
egui::Frame::new()
|
||
.fill(WIDGET_BG)
|
||
.stroke(egui::Stroke::new(1.0, BORDER))
|
||
.corner_radius(egui::CornerRadius::same(4))
|
||
.inner_margin(egui::Margin::symmetric(8, 8))
|
||
.show(ui, |ui| {
|
||
ui.horizontal(|ui| {
|
||
let caret = if context.collapsed {
|
||
icons::CARET_RIGHT
|
||
} else {
|
||
icons::CARET_DOWN
|
||
};
|
||
if ui
|
||
.add(
|
||
egui::Button::new(phosphor_icon(caret, 13.0).color(TEXT_DIM))
|
||
.frame(false)
|
||
.min_size(egui::vec2(20.0, 20.0)),
|
||
)
|
||
.on_hover_text(if context.collapsed {
|
||
"Expand component"
|
||
} else {
|
||
"Collapse component"
|
||
})
|
||
.clicked()
|
||
{
|
||
response.collapsed = Some(!context.collapsed);
|
||
}
|
||
ui.label(phosphor_icon(context.options.icon, 16.0).color(TEXT_DIM));
|
||
ui.label(panel_heading(context.options.title));
|
||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||
let menu = ui.menu_button(
|
||
phosphor_icon(icons::DOTS_THREE_VERTICAL, 16.0).color(TEXT_DIM),
|
||
|ui| {
|
||
ui.set_min_width(160.0);
|
||
if ui
|
||
.add_enabled(context.options.resettable, egui::Button::new("Reset"))
|
||
.clicked()
|
||
{
|
||
response.reset = true;
|
||
ui.close();
|
||
}
|
||
if ui
|
||
.add_enabled(
|
||
context.options.copyable,
|
||
egui::Button::new("Copy Values"),
|
||
)
|
||
.clicked()
|
||
{
|
||
response.copy = true;
|
||
ui.close();
|
||
}
|
||
if ui
|
||
.add_enabled(context.pasteable, egui::Button::new("Paste Values"))
|
||
.clicked()
|
||
{
|
||
response.paste = true;
|
||
ui.close();
|
||
}
|
||
ui.separator();
|
||
if ui
|
||
.add_enabled(context.can_move_up, egui::Button::new("Move Up"))
|
||
.clicked()
|
||
{
|
||
response.move_up = true;
|
||
ui.close();
|
||
}
|
||
if ui
|
||
.add_enabled(context.can_move_down, egui::Button::new("Move Down"))
|
||
.clicked()
|
||
{
|
||
response.move_down = true;
|
||
ui.close();
|
||
}
|
||
ui.separator();
|
||
ui.add_enabled(false, egui::Button::new("Open Documentation"));
|
||
if ui
|
||
.add_enabled(
|
||
context.options.removable,
|
||
egui::Button::new(
|
||
egui::RichText::new("Remove")
|
||
.color(egui::Color32::from_rgb(255, 137, 129)),
|
||
),
|
||
)
|
||
.clicked()
|
||
{
|
||
response.remove = true;
|
||
ui.close();
|
||
}
|
||
},
|
||
);
|
||
menu.response.on_hover_text("Component actions");
|
||
if context.options.active_toggle {
|
||
if status_dot_button(
|
||
ui,
|
||
if context.active {
|
||
egui::Color32::from_rgb(74, 181, 104)
|
||
} else {
|
||
TEXT_MUTED
|
||
},
|
||
if context.active {
|
||
"Component active. Click to disable."
|
||
} else {
|
||
"Component disabled. Click to enable."
|
||
},
|
||
)
|
||
.clicked()
|
||
{
|
||
response.active = Some(!context.active);
|
||
}
|
||
} else {
|
||
status_dot(
|
||
ui,
|
||
egui::Color32::from_rgb(74, 181, 104),
|
||
"Component active",
|
||
);
|
||
}
|
||
});
|
||
});
|
||
if !context.collapsed {
|
||
ui.add_space(4.0);
|
||
egui::Frame::new()
|
||
.fill(ELEVATED_BG.linear_multiply(0.35))
|
||
.corner_radius(egui::CornerRadius::same(4))
|
||
.inner_margin(egui::Margin::symmetric(8, 8))
|
||
.show(ui, |ui| {
|
||
ui.set_clip_rect(ui.max_rect());
|
||
ui.set_max_width(ui.available_width());
|
||
add_contents(ui);
|
||
});
|
||
}
|
||
});
|
||
ui.add_space(6.0);
|
||
response
|
||
}
|
||
|
||
pub(crate) fn property_row<R>(
|
||
ui: &mut egui::Ui,
|
||
label: &str,
|
||
add_contents: impl FnOnce(&mut egui::Ui) -> R,
|
||
) -> R {
|
||
if ui.available_width() < COMPACT_INSPECTOR_WIDTH {
|
||
ui.vertical(|ui| {
|
||
ui.label(label);
|
||
add_contents(ui)
|
||
})
|
||
.inner
|
||
} else {
|
||
ui.horizontal(|ui| {
|
||
let label_width = PROPERTY_LABEL_WIDTH.min(ui.available_width().max(1.0));
|
||
ui.add_sized([label_width, 20.0], egui::Label::new(label));
|
||
add_contents(ui)
|
||
})
|
||
.inner
|
||
}
|
||
}
|
||
|
||
pub(crate) fn text_field_width(ui: &egui::Ui) -> f32 {
|
||
fit_width(ui, MIN_INLINE_CONTROL_WIDTH, TEXT_FIELD_MAX_WIDTH).min(ui.available_width().max(1.0))
|
||
}
|
||
|
||
pub fn material_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let mut material = world
|
||
.get::<MaterialDesc>(entity)
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
request_texture_asset_thumbnails(world);
|
||
let texture_candidates = texture_asset_candidates(world);
|
||
let original = material.clone();
|
||
let mut changed = false;
|
||
let mut options = ComponentCardOptions::removable(
|
||
COMPONENT_MATERIAL_DESC,
|
||
"Authoring Material",
|
||
icons::PALETTE,
|
||
);
|
||
options.removable = world.get::<MaterialDesc>(entity).is_some();
|
||
options.copyable = options.removable;
|
||
let card = component_card_context(world, entity, options);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
changed |= material_shader_ui(ui, &mut material);
|
||
let mut color = [
|
||
material.base_color.r,
|
||
material.base_color.g,
|
||
material.base_color.b,
|
||
material.base_color.a,
|
||
];
|
||
property_row(ui, "Base color", |ui| {
|
||
if ui.color_edit_button_rgba_unmultiplied(&mut color).changed() {
|
||
material.base_color = ColorDesc {
|
||
r: color[0],
|
||
g: color[1],
|
||
b: color[2],
|
||
a: color[3],
|
||
};
|
||
changed = true;
|
||
}
|
||
});
|
||
property_row(ui, "Metallic", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut material.metallic, 0.0..=1.0))
|
||
.changed();
|
||
});
|
||
property_row(ui, "Roughness", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut material.roughness, 0.0..=1.0))
|
||
.changed();
|
||
});
|
||
|
||
let mut emissive_color = [
|
||
material.emissive_color.r,
|
||
material.emissive_color.g,
|
||
material.emissive_color.b,
|
||
material.emissive_color.a,
|
||
];
|
||
property_row(ui, "Emissive", |ui| {
|
||
if ui
|
||
.color_edit_button_rgba_unmultiplied(&mut emissive_color)
|
||
.changed()
|
||
{
|
||
material.emissive_color = ColorDesc {
|
||
r: emissive_color[0],
|
||
g: emissive_color[1],
|
||
b: emissive_color[2],
|
||
a: emissive_color[3],
|
||
};
|
||
changed = true;
|
||
}
|
||
});
|
||
property_row(ui, "Emissive nits", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(
|
||
&mut material.emissive_intensity,
|
||
0.0..=20_000.0,
|
||
))
|
||
.changed();
|
||
});
|
||
|
||
changed |= texture_asset_picker_ui(
|
||
world,
|
||
ui,
|
||
"Base color texture",
|
||
&mut material.base_color_texture,
|
||
&texture_candidates,
|
||
);
|
||
changed |= texture_asset_picker_ui(
|
||
world,
|
||
ui,
|
||
"Emissive texture",
|
||
&mut material.emissive_texture,
|
||
&texture_candidates,
|
||
);
|
||
changed |= texture_asset_picker_ui(
|
||
world,
|
||
ui,
|
||
"Normal map",
|
||
&mut material.normal_map_texture,
|
||
&texture_candidates,
|
||
);
|
||
changed |= texture_asset_picker_ui(
|
||
world,
|
||
ui,
|
||
"Metallic/roughness texture",
|
||
&mut material.metallic_roughness_texture,
|
||
&texture_candidates,
|
||
);
|
||
|
||
if crate::assets::materials::material_asset_picker_ui(
|
||
world,
|
||
ui,
|
||
entity,
|
||
&mut material,
|
||
&original,
|
||
) {
|
||
changed = true;
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
|
||
if changed && !material_eq(&original, &material) {
|
||
set_material_with_history(world, entity, material);
|
||
}
|
||
}
|
||
|
||
fn brush_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let material_candidates = brush_face_material_ref_candidates(world);
|
||
request_texture_asset_thumbnails(world);
|
||
let texture_candidates = texture_asset_ref_candidates(world);
|
||
let Some(mut brush) = world.get::<BrushDesc>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let original = brush.clone();
|
||
let mut changed = false;
|
||
let mut reset_cube = false;
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_BRUSH_DESC, "Brush", icons::CUBE),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Kind", |ui| {
|
||
egui::ComboBox::from_id_salt("brush_kind")
|
||
.selected_text(match brush.kind {
|
||
BrushKind::Additive => "Additive",
|
||
BrushKind::SubtractiveMarker => "Subtractive Marker",
|
||
})
|
||
.show_ui(ui, |ui| {
|
||
changed |= ui
|
||
.selectable_value(&mut brush.kind, BrushKind::Additive, "Additive")
|
||
.changed();
|
||
changed |= ui
|
||
.selectable_value(
|
||
&mut brush.kind,
|
||
BrushKind::SubtractiveMarker,
|
||
"Subtractive Marker",
|
||
)
|
||
.changed();
|
||
});
|
||
});
|
||
property_row(ui, "Faces", |ui| {
|
||
ui.label(format!("{}", brush.faces.len()));
|
||
});
|
||
property_row(ui, "Shadows", |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
changed |= ui.checkbox(&mut brush.cast_shadows, "Cast").changed();
|
||
changed |= ui.checkbox(&mut brush.receive_shadows, "Receive").changed();
|
||
});
|
||
});
|
||
brush_validation_ui(ui, &brush);
|
||
changed |= selected_brush_face_controls(
|
||
world,
|
||
ui,
|
||
entity,
|
||
&mut brush,
|
||
&material_candidates,
|
||
&texture_candidates,
|
||
);
|
||
if ui.button("Reset Cube Brush").clicked() {
|
||
reset_cube = true;
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
|
||
if reset_cube {
|
||
brush = BrushDesc::default();
|
||
changed = true;
|
||
}
|
||
if changed && brush != original {
|
||
set_brush_with_history(world, entity, brush);
|
||
}
|
||
}
|
||
|
||
fn terrain_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut terrain) = world.get::<TerrainDesc>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let original = terrain.clone();
|
||
let mut changed = false;
|
||
let mut requested_resolution = terrain.resolution;
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_TERRAIN_DESC, "Terrain", icons::MOUNTAINS),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Grid", |ui| {
|
||
ui.horizontal(|ui| {
|
||
ui.add(
|
||
egui::DragValue::new(&mut requested_resolution)
|
||
.range(2..=1025)
|
||
.suffix(" samples"),
|
||
);
|
||
if ui
|
||
.add_enabled(
|
||
requested_resolution != terrain.resolution,
|
||
egui::Button::new("Resize Flat"),
|
||
)
|
||
.on_hover_text("Replaces the current height grid with a flat grid")
|
||
.clicked()
|
||
{
|
||
let replacement = TerrainDesc::flat(requested_resolution);
|
||
terrain.resolution = replacement.resolution;
|
||
terrain.heights = replacement.heights;
|
||
terrain.chunk_quads = terrain.chunk_quads.min(terrain.resolution - 1).max(1);
|
||
changed = true;
|
||
}
|
||
});
|
||
});
|
||
property_row(ui, "Sample Spacing", |ui| {
|
||
changed |= ui
|
||
.add(
|
||
egui::DragValue::new(&mut terrain.sample_spacing)
|
||
.range(0.01..=1000.0)
|
||
.speed(0.1)
|
||
.suffix(" m"),
|
||
)
|
||
.changed();
|
||
});
|
||
property_row(ui, "Height Scale", |ui| {
|
||
changed |= ui
|
||
.add(
|
||
egui::DragValue::new(&mut terrain.height_scale)
|
||
.range(0.01..=10000.0)
|
||
.speed(0.1)
|
||
.suffix(" m"),
|
||
)
|
||
.changed();
|
||
});
|
||
property_row(ui, "Chunk Size", |ui| {
|
||
changed |= ui
|
||
.add(
|
||
egui::DragValue::new(&mut terrain.chunk_quads)
|
||
.range(1..=terrain.resolution.saturating_sub(1))
|
||
.suffix(" quads"),
|
||
)
|
||
.changed();
|
||
});
|
||
property_row(ui, "Collision", |ui| {
|
||
changed |= ui
|
||
.checkbox(&mut terrain.generate_colliders, "Generate")
|
||
.changed();
|
||
});
|
||
property_row(ui, "Shadows", |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
changed |= ui.checkbox(&mut terrain.cast_shadows, "Cast").changed();
|
||
changed |= ui
|
||
.checkbox(&mut terrain.receive_shadows, "Receive")
|
||
.changed();
|
||
});
|
||
});
|
||
property_row(ui, "Base Material", |ui| {
|
||
ui.label(
|
||
terrain
|
||
.base_material
|
||
.as_ref()
|
||
.map(|material| material.label.as_str())
|
||
.filter(|label| !label.is_empty())
|
||
.unwrap_or("Terrain fallback"),
|
||
);
|
||
});
|
||
match terrain.validate() {
|
||
Ok(()) => {
|
||
ui.label(
|
||
egui::RichText::new(format!(
|
||
"{} heights • {}×{} chunks",
|
||
terrain.heights.len(),
|
||
(terrain.resolution - 1).div_ceil(terrain.chunk_quads),
|
||
(terrain.resolution - 1).div_ceil(terrain.chunk_quads)
|
||
))
|
||
.color(super::theme::SUCCESS),
|
||
);
|
||
}
|
||
Err(error) => {
|
||
ui.label(egui::RichText::new(error).color(super::theme::ERROR));
|
||
}
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
|
||
if changed && terrain != original {
|
||
let _ = reflected_component_transaction(
|
||
world,
|
||
entity,
|
||
"Edit Terrain",
|
||
shared::AUTHORING_COMPONENT_TERRAIN,
|
||
COMPONENT_TERRAIN_DESC,
|
||
move |world, entity| {
|
||
world.entity_mut(entity).insert(terrain);
|
||
Ok(())
|
||
},
|
||
);
|
||
}
|
||
}
|
||
|
||
fn brush_validation_ui(ui: &mut egui::Ui, brush: &BrushDesc) {
|
||
let report = validate_brush(brush);
|
||
if report.diagnostics.is_empty() {
|
||
return;
|
||
}
|
||
|
||
ui.add_space(6.0);
|
||
egui::Frame::new()
|
||
.fill(egui::Color32::from_rgb(31, 32, 36))
|
||
.stroke(egui::Stroke::new(1.0, BORDER))
|
||
.inner_margin(egui::Margin::symmetric(8, 6))
|
||
.show(ui, |ui| {
|
||
let has_errors = !report.is_valid();
|
||
let title_color = if has_errors {
|
||
egui::Color32::from_rgb(255, 137, 129)
|
||
} else {
|
||
egui::Color32::from_rgb(255, 190, 110)
|
||
};
|
||
ui.horizontal(|ui| {
|
||
let icon = if has_errors {
|
||
icons::WARNING
|
||
} else {
|
||
icons::INFO
|
||
};
|
||
ui.label(phosphor_icon(icon, 14.0).color(title_color));
|
||
ui.label(
|
||
egui::RichText::new(if has_errors {
|
||
"Brush geometry needs repair"
|
||
} else {
|
||
"Brush diagnostics"
|
||
})
|
||
.color(title_color),
|
||
);
|
||
});
|
||
for diagnostic in report.diagnostics.iter().take(4) {
|
||
let color = match diagnostic.severity {
|
||
BrushDiagnosticSeverity::Error => egui::Color32::from_rgb(255, 137, 129),
|
||
BrushDiagnosticSeverity::Warning => egui::Color32::from_rgb(255, 190, 110),
|
||
};
|
||
let face = diagnostic
|
||
.face
|
||
.as_ref()
|
||
.filter(|face| !face.is_empty())
|
||
.map(|face| format!("{}: ", face.0))
|
||
.unwrap_or_default();
|
||
ui.label(egui::RichText::new(format!("{face}{}", diagnostic.message)).color(color));
|
||
}
|
||
let hidden_count = report.diagnostics.len().saturating_sub(4);
|
||
if hidden_count > 0 {
|
||
ui.label(egui::RichText::new(format!("+{hidden_count} more")).color(TEXT_MUTED));
|
||
}
|
||
});
|
||
}
|
||
|
||
fn selected_brush_face_controls(
|
||
world: &mut World,
|
||
ui: &mut egui::Ui,
|
||
entity: Entity,
|
||
brush: &mut BrushDesc,
|
||
material_candidates: &[AssetRefCandidate],
|
||
texture_candidates: &[AssetRefCandidate],
|
||
) -> bool {
|
||
let Some(selection) = world.get_resource::<BrushElementSelection>() else {
|
||
return false;
|
||
};
|
||
if selection.brush != Some(entity) {
|
||
return false;
|
||
}
|
||
let selected_faces: Vec<_> = selection
|
||
.elements
|
||
.iter()
|
||
.filter_map(|element| match element {
|
||
BrushElementKey::Face { face } => Some(face.clone()),
|
||
_ => None,
|
||
})
|
||
.collect();
|
||
if selected_faces.is_empty() {
|
||
return false;
|
||
}
|
||
|
||
let dragging_selection = world
|
||
.get_resource::<EditorAssets>()
|
||
.and_then(|assets| assets.dragging_selection().cloned());
|
||
let material_drop_candidate = dragging_selection.as_ref().and_then(|selection| {
|
||
asset_ref_candidate_from_selection(world, selection, AssetRefCandidateKind::Material)
|
||
});
|
||
let texture_drop_candidate = dragging_selection.as_ref().and_then(|selection| {
|
||
asset_ref_candidate_from_selection(world, selection, AssetRefCandidateKind::Texture)
|
||
});
|
||
let mut changed = false;
|
||
ui.add_space(6.0);
|
||
ui.separator();
|
||
ui.label(
|
||
egui::RichText::new(format!("{} selected face(s)", selected_faces.len())).color(TEXT_DIM),
|
||
);
|
||
|
||
for face_id in selected_faces {
|
||
let Some(face) = brush.faces.iter_mut().find(|face| face.id == face_id) else {
|
||
continue;
|
||
};
|
||
let label = if face.id.0.trim().is_empty() {
|
||
"Face".to_string()
|
||
} else {
|
||
face.id.0.clone()
|
||
};
|
||
egui::CollapsingHeader::new(label)
|
||
.default_open(true)
|
||
.show(ui, |ui| {
|
||
property_row(ui, "UV offset", |ui| {
|
||
changed |= ui
|
||
.add(egui::DragValue::new(&mut face.uv_offset.x).speed(0.05))
|
||
.changed();
|
||
changed |= ui
|
||
.add(egui::DragValue::new(&mut face.uv_offset.y).speed(0.05))
|
||
.changed();
|
||
});
|
||
property_row(ui, "UV scale", |ui| {
|
||
changed |= ui
|
||
.add(egui::DragValue::new(&mut face.uv_scale.x).speed(0.05))
|
||
.changed();
|
||
changed |= ui
|
||
.add(egui::DragValue::new(&mut face.uv_scale.y).speed(0.05))
|
||
.changed();
|
||
});
|
||
property_row(ui, "UV rotation", |ui| {
|
||
changed |= ui
|
||
.add(egui::DragValue::new(&mut face.uv_rotation).speed(1.0))
|
||
.changed();
|
||
});
|
||
let material_response = asset_selector_row(
|
||
ui,
|
||
"Material",
|
||
icons::PALETTE,
|
||
face.material.as_ref(),
|
||
None,
|
||
true,
|
||
material_candidates,
|
||
material_drop_candidate.as_ref(),
|
||
);
|
||
if let Some(selected) = material_response.selected {
|
||
face.material = Some(selected);
|
||
changed = true;
|
||
}
|
||
if material_response.clear {
|
||
face.material = None;
|
||
changed = true;
|
||
}
|
||
if material_response.locate {
|
||
locate_asset_ref(world, face.material.as_ref(), material_candidates);
|
||
}
|
||
if material_response.accepted_drop {
|
||
clear_asset_drag(world);
|
||
}
|
||
|
||
let texture_response = asset_selector_row(
|
||
ui,
|
||
"Texture",
|
||
icons::IMAGE,
|
||
face.texture.as_ref(),
|
||
None,
|
||
true,
|
||
texture_candidates,
|
||
texture_drop_candidate.as_ref(),
|
||
);
|
||
if let Some(selected) = texture_response.selected {
|
||
face.texture = Some(selected);
|
||
changed = true;
|
||
}
|
||
if texture_response.clear {
|
||
face.texture = None;
|
||
changed = true;
|
||
}
|
||
if texture_response.locate {
|
||
locate_asset_ref(world, face.texture.as_ref(), texture_candidates);
|
||
}
|
||
if texture_response.accepted_drop {
|
||
clear_asset_drag(world);
|
||
}
|
||
});
|
||
}
|
||
|
||
changed
|
||
}
|
||
|
||
fn clear_asset_drag(world: &mut World) {
|
||
if let Some(mut assets) = world.get_resource_mut::<EditorAssets>() {
|
||
assets.clear_drag();
|
||
}
|
||
}
|
||
|
||
fn primitive_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut primitive) = world.get::<Primitive>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let _original = primitive.clone();
|
||
let mut changed = false;
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_PRIMITIVE, "Primitive", icons::CUBE),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Shape", |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
for (label, shape) in [
|
||
("Box", PrimitiveShape::Box),
|
||
("Sphere", PrimitiveShape::Sphere),
|
||
("Ramp", PrimitiveShape::Ramp),
|
||
] {
|
||
changed |= ui
|
||
.selectable_value(&mut primitive.shape, shape, label)
|
||
.changed();
|
||
}
|
||
});
|
||
});
|
||
property_row(ui, "Size X", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut primitive.size.x, 0.1..=20.0))
|
||
.changed();
|
||
});
|
||
property_row(ui, "Size Y", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut primitive.size.y, 0.1..=20.0))
|
||
.changed();
|
||
});
|
||
property_row(ui, "Size Z", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut primitive.size.z, 0.1..=20.0))
|
||
.changed();
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if changed {
|
||
set_primitive_with_history(world, entity, primitive);
|
||
}
|
||
}
|
||
|
||
fn light_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut light) = world.get::<LightDesc>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let _original = light.clone();
|
||
let mut changed = false;
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_LIGHT_DESC, "Light", icons::LIGHTBULB),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Kind", |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
for (label, kind) in [
|
||
("Point", AuthoringLightKind::Point),
|
||
("Spot", AuthoringLightKind::Spot),
|
||
("Directional", AuthoringLightKind::Directional),
|
||
] {
|
||
if ui.selectable_label(light.kind == kind, label).clicked() {
|
||
let color = light.color;
|
||
light = LightDesc {
|
||
color,
|
||
..LightDesc::for_kind(kind)
|
||
};
|
||
changed = true;
|
||
}
|
||
}
|
||
});
|
||
});
|
||
let solari_disabled = solari_disables_local_light(world, &light);
|
||
if solari_disabled {
|
||
ui.colored_label(
|
||
egui::Color32::from_rgb(255, 180, 100),
|
||
"Point and spot lights are disabled while Solari is active. Use a directional light or emissive material, or switch GI to Forward.",
|
||
);
|
||
}
|
||
ui.add_enabled_ui(!solari_disabled, |ui| {
|
||
let mut color = [light.color.r, light.color.g, light.color.b, light.color.a];
|
||
property_row(ui, "Color", |ui| {
|
||
if ui.color_edit_button_rgba_unmultiplied(&mut color).changed() {
|
||
light.color = ColorDesc {
|
||
r: color[0],
|
||
g: color[1],
|
||
b: color[2],
|
||
a: color[3],
|
||
};
|
||
changed = true;
|
||
}
|
||
});
|
||
let intensity_label = match light.kind {
|
||
AuthoringLightKind::Directional => "Intensity (lux)",
|
||
_ => "Intensity (lumens)",
|
||
};
|
||
let intensity_max = match light.kind {
|
||
AuthoringLightKind::Directional => AUTHORING_DIRECTIONAL_LUX_MAX,
|
||
_ => AUTHORING_POINT_SPOT_LUMENS_MAX,
|
||
};
|
||
property_row(ui, intensity_label, |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
if ui
|
||
.add(
|
||
egui::Slider::new(&mut light.intensity, 0.0..=intensity_max)
|
||
.show_value(false),
|
||
)
|
||
.changed()
|
||
{
|
||
changed = true;
|
||
}
|
||
if ui
|
||
.add_sized(
|
||
[fit_width(ui, 72.0, 120.0), 20.0],
|
||
egui::DragValue::new(&mut light.intensity)
|
||
.range(0.0..=intensity_max)
|
||
.speed(intensity_max * 0.001),
|
||
)
|
||
.changed()
|
||
{
|
||
changed = true;
|
||
}
|
||
});
|
||
});
|
||
if matches!(
|
||
light.kind,
|
||
AuthoringLightKind::Point | AuthoringLightKind::Spot
|
||
) {
|
||
property_row(ui, "Range (m)", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut light.range, 0.0..=100.0))
|
||
.changed();
|
||
});
|
||
}
|
||
if matches!(light.kind, AuthoringLightKind::Spot) {
|
||
property_row(ui, "Inner angle", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut light.inner_angle_deg, 1.0..=80.0))
|
||
.changed();
|
||
});
|
||
property_row(ui, "Outer angle", |ui| {
|
||
changed |= ui
|
||
.add(egui::Slider::new(&mut light.outer_angle_deg, 1.0..=90.0))
|
||
.changed();
|
||
});
|
||
}
|
||
property_row(ui, "Shadows", |ui| {
|
||
changed |= ui.checkbox(&mut light.shadows, "Cast shadows").changed();
|
||
});
|
||
if matches!(light.kind, AuthoringLightKind::Directional) {
|
||
ui.small("Controls project sun while this directional exists.");
|
||
}
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if changed {
|
||
set_light_with_history(world, entity, light);
|
||
}
|
||
}
|
||
|
||
fn solari_disables_local_light(world: &World, light: &LightDesc) -> bool {
|
||
matches!(
|
||
light.kind,
|
||
AuthoringLightKind::Point | AuthoringLightKind::Spot
|
||
) && world
|
||
.get_resource::<settings::ActiveCameraRenderProfile>()
|
||
.is_some_and(|profile| profile.gi_path == settings::GiPath::SolariDeferred)
|
||
&& world
|
||
.get_resource::<settings::RenderingCapabilities>()
|
||
.is_some_and(|caps| caps.rt_supported)
|
||
}
|
||
|
||
fn rigid_body_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut body) = world.get::<RigidBodyDesc>(entity).copied() else {
|
||
return;
|
||
};
|
||
let original = body;
|
||
let mut changed = false;
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_RIGID_BODY_DESC, "Rigid Body", icons::SPHERE),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Body", |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
for (label, kind) in [
|
||
("Static", AuthoringRigidBody::Static),
|
||
("Kinematic", AuthoringRigidBody::Kinematic),
|
||
("Dynamic", AuthoringRigidBody::Dynamic),
|
||
] {
|
||
changed |= ui.selectable_value(&mut body.body, kind, label).changed();
|
||
}
|
||
});
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if changed && body != original {
|
||
set_rigid_body_with_history(world, entity, body);
|
||
}
|
||
}
|
||
|
||
fn collider_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let mesh_candidates = static_mesh_asset_ref_candidates(world, AssetRefCandidateKind::Mesh);
|
||
let Some(mut collider) = world.get::<ColliderDesc>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let original = collider.clone();
|
||
let mut changed = false;
|
||
let renderer_meshes: Vec<EditorAssetRef> = world
|
||
.get::<StaticMeshRenderer>(entity)
|
||
.map(|renderer| {
|
||
renderer
|
||
.slots
|
||
.iter()
|
||
.map(|slot| slot.mesh.clone())
|
||
.collect()
|
||
})
|
||
.unwrap_or_default();
|
||
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_COLLIDER_DESC, "Collider", icons::SELECTION),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Mode", |ui| {
|
||
changed |= ui.checkbox(&mut collider.enabled, "Enabled").changed();
|
||
changed |= ui.checkbox(&mut collider.is_trigger, "Trigger").changed();
|
||
});
|
||
property_row(ui, "Shape", |ui| {
|
||
let mut shape_kind = collider_shape_kind(&collider.shape);
|
||
egui::ComboBox::from_id_salt("collider_shape_kind")
|
||
.selected_text(shape_kind)
|
||
.show_ui(ui, |ui| {
|
||
for label in ["Box", "Sphere", "Capsule", "Static Mesh"] {
|
||
if ui.selectable_label(shape_kind == label, label).clicked() {
|
||
shape_kind = label;
|
||
}
|
||
}
|
||
});
|
||
if shape_kind != collider_shape_kind(&collider.shape) {
|
||
collider.shape = match shape_kind {
|
||
"Sphere" => ColliderShapeDesc::Sphere { radius: 0.5 },
|
||
"Capsule" => ColliderShapeDesc::Capsule {
|
||
radius: 0.5,
|
||
height: 1.0,
|
||
},
|
||
"Static Mesh" => ColliderShapeDesc::static_mesh(renderer_meshes.clone()),
|
||
_ => ColliderShapeDesc::default(),
|
||
};
|
||
changed = true;
|
||
}
|
||
});
|
||
|
||
match &mut collider.shape {
|
||
ColliderShapeDesc::Cuboid {
|
||
x_length,
|
||
y_length,
|
||
z_length,
|
||
} => {
|
||
changed |= dimension_drag(ui, "X", x_length);
|
||
changed |= dimension_drag(ui, "Y", y_length);
|
||
changed |= dimension_drag(ui, "Z", z_length);
|
||
}
|
||
ColliderShapeDesc::Sphere { radius } => {
|
||
changed |= dimension_drag(ui, "Radius", radius);
|
||
}
|
||
ColliderShapeDesc::Capsule { radius, height } => {
|
||
changed |= dimension_drag(ui, "Radius", radius);
|
||
changed |= dimension_drag(ui, "Height", height);
|
||
}
|
||
ColliderShapeDesc::StaticMesh { meshes, .. } => {
|
||
if meshes.is_empty() {
|
||
ui.label(egui::RichText::new("No mesh collider sources").color(TEXT_DIM));
|
||
}
|
||
for mesh in meshes.iter_mut() {
|
||
let mesh_response = asset_selector_row(
|
||
ui,
|
||
"Mesh",
|
||
icons::CUBE,
|
||
Some(mesh),
|
||
None,
|
||
false,
|
||
&mesh_candidates,
|
||
None,
|
||
);
|
||
if let Some(selected) = mesh_response.selected {
|
||
*mesh = selected;
|
||
changed = true;
|
||
}
|
||
if mesh_response.locate {
|
||
locate_asset_ref(world, Some(mesh), &mesh_candidates);
|
||
}
|
||
}
|
||
if !renderer_meshes.is_empty() && ui.button("Use renderer meshes").clicked() {
|
||
*meshes = renderer_meshes.clone();
|
||
changed = true;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
|
||
if changed && collider != original {
|
||
set_collider_with_history(world, entity, collider);
|
||
}
|
||
}
|
||
|
||
fn collider_shape_kind(shape: &ColliderShapeDesc) -> &'static str {
|
||
match shape {
|
||
ColliderShapeDesc::Cuboid { .. } => "Box",
|
||
ColliderShapeDesc::Sphere { .. } => "Sphere",
|
||
ColliderShapeDesc::Capsule { .. } => "Capsule",
|
||
ColliderShapeDesc::StaticMesh { .. } => "Static Mesh",
|
||
}
|
||
}
|
||
|
||
fn dimension_drag(ui: &mut egui::Ui, label: &str, value: &mut f32) -> bool {
|
||
property_row(ui, label, |ui| {
|
||
ui.add_sized(
|
||
[fit_width(ui, 72.0, 120.0), 20.0],
|
||
egui::DragValue::new(value)
|
||
.range(0.0..=10_000.0)
|
||
.speed(0.05)
|
||
.min_decimals(2)
|
||
.max_decimals(3),
|
||
)
|
||
.changed()
|
||
})
|
||
}
|
||
|
||
fn physics_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut body) = world.get::<PhysicsBody>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let _original = body.clone();
|
||
let mut changed = false;
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_PHYSICS_BODY, "Physics", icons::SPHERE),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Body", |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
for (label, kind) in [
|
||
("Static", AuthoringRigidBody::Static),
|
||
("Kinematic", AuthoringRigidBody::Kinematic),
|
||
("Dynamic", AuthoringRigidBody::Dynamic),
|
||
] {
|
||
if ui.selectable_label(body.body == kind, label).clicked() {
|
||
body.body = kind;
|
||
changed = true;
|
||
}
|
||
}
|
||
});
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if changed {
|
||
set_physics_with_history(world, entity, body);
|
||
}
|
||
}
|
||
|
||
fn player_spawn_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
if world.get::<PlayerSpawn>(entity).is_none() {
|
||
return;
|
||
}
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(
|
||
COMPONENT_PLAYER_SPAWN,
|
||
"Player Spawn",
|
||
icons::PERSON_SIMPLE_RUN,
|
||
),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
ui.label(
|
||
egui::RichText::new("Uses this actor transform as a player start.").color(TEXT_DIM),
|
||
);
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
}
|
||
|
||
fn weapon_spawn_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut spawn) = world.get::<WeaponSpawn>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_WEAPON_SPAWN, "Weapon Spawn", icons::CROSSHAIR),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Weapon ID", |ui| {
|
||
ui.add_sized(
|
||
[text_field_width(ui), 20.0],
|
||
egui::TextEdit::singleline(&mut spawn.weapon_id),
|
||
);
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if let Ok(mut e) = world.get_entity_mut(entity) {
|
||
e.insert(spawn);
|
||
}
|
||
}
|
||
|
||
fn trigger_volume_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut trigger) = world.get::<TriggerVolume>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(
|
||
COMPONENT_TRIGGER_VOLUME,
|
||
"Trigger Volume",
|
||
icons::SELECTION,
|
||
),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Event", |ui| {
|
||
ui.add_sized(
|
||
[text_field_width(ui), 20.0],
|
||
egui::TextEdit::singleline(&mut trigger.event_name),
|
||
);
|
||
});
|
||
property_row(ui, "Half X", |ui| {
|
||
ui.add(egui::Slider::new(&mut trigger.half_extents.x, 0.1..=50.0));
|
||
});
|
||
property_row(ui, "Half Y", |ui| {
|
||
ui.add(egui::Slider::new(&mut trigger.half_extents.y, 0.1..=50.0));
|
||
});
|
||
property_row(ui, "Half Z", |ui| {
|
||
ui.add(egui::Slider::new(&mut trigger.half_extents.z, 0.1..=50.0));
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if let Ok(mut e) = world.get_entity_mut(entity) {
|
||
e.insert(trigger);
|
||
}
|
||
}
|
||
|
||
fn team_spawn_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut spawn) = world.get::<TeamSpawn>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_TEAM_SPAWN, "Team Spawn", icons::FLAG),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Team", |ui| {
|
||
ui.add(egui::Slider::new(&mut spawn.team_id, 0..=8));
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if let Ok(mut e) = world.get_entity_mut(entity) {
|
||
e.insert(spawn);
|
||
}
|
||
}
|
||
|
||
fn objective_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
let Some(mut marker) = world.get::<ObjectiveMarker>(entity).cloned() else {
|
||
return;
|
||
};
|
||
let card = component_card_context(
|
||
world,
|
||
entity,
|
||
ComponentCardOptions::removable(COMPONENT_OBJECTIVE_MARKER, "Objective", icons::TARGET),
|
||
);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
property_row(ui, "Objective ID", |ui| {
|
||
ui.add_sized(
|
||
[text_field_width(ui), 20.0],
|
||
egui::TextEdit::singleline(&mut marker.objective_id),
|
||
);
|
||
});
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
if let Ok(mut e) = world.get_entity_mut(entity) {
|
||
e.insert(marker);
|
||
}
|
||
}
|
||
|
||
fn prefab_instance_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
crate::assets::prefab_overrides::prefab_instance_inspector_ui(world, ui, entity);
|
||
}
|
||
|
||
pub fn project_sun_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||
if world.get::<ProjectSun>(entity).is_none() {
|
||
return;
|
||
}
|
||
|
||
let rendering = world
|
||
.resource::<settings::ProjectSettings>()
|
||
.rendering
|
||
.clone();
|
||
let scene_override_active = has_scene_sun_override(world);
|
||
let mut create_override = false;
|
||
let mut options = ComponentCardOptions::fixed(COMPONENT_PROJECT_SUN, "Project Sun", icons::SUN);
|
||
options.resettable = false;
|
||
let card = component_card_context(world, entity, options);
|
||
let card_response = component_card(ui, &card, |ui| {
|
||
ui.label("Runtime default world lighting from assets/project.ron.");
|
||
property_row(ui, "Illuminance", |ui| {
|
||
ui.small(format!("{:.0} lux", rendering.sun_illuminance));
|
||
});
|
||
property_row(ui, "Ambient", |ui| {
|
||
ui.small(format!(
|
||
"{:.2}, {:.2}, {:.2} @ {:.1}",
|
||
rendering.ambient_color[0],
|
||
rendering.ambient_color[1],
|
||
rendering.ambient_color[2],
|
||
rendering.ambient_brightness
|
||
));
|
||
});
|
||
property_row(ui, "Shadows", |ui| {
|
||
ui.small(format!(
|
||
"{} cascades, max {:.0}m",
|
||
rendering.shadow_cascades, rendering.shadow_max_distance
|
||
));
|
||
});
|
||
if scene_override_active {
|
||
ui.label(egui::RichText::new("Scene sun override is active.").weak());
|
||
} else if ui.button("Create Scene Sun Override").clicked() {
|
||
create_override = true;
|
||
}
|
||
});
|
||
apply_component_card_response(world, entity, card_response);
|
||
|
||
if create_override {
|
||
let sun = create_scene_sun_override_from_project_settings(world);
|
||
world.resource_mut::<SelectedEntity>().0 = Some(sun);
|
||
if let Some(mut ui_state) = world.get_resource_mut::<crate::ui::UiState>() {
|
||
ui_state.selected_entities.select_replace(sun);
|
||
}
|
||
}
|
||
}
|
||
|
||
fn has_scene_sun_override(world: &mut World) -> bool {
|
||
world
|
||
.query_filtered::<(
|
||
&shared::LightDesc,
|
||
Option<&AuthoringComponentStates>,
|
||
Option<&InspectorOrder>,
|
||
), With<LevelObject>>()
|
||
.iter(world)
|
||
.any(|(light, states, legacy_order)| {
|
||
authoring_component_active(states, legacy_order, COMPONENT_LIGHT_DESC)
|
||
&& matches!(light.kind, shared::AuthoringLightKind::Directional)
|
||
})
|
||
}
|
||
|
||
fn texture_asset_picker_ui(
|
||
world: &mut World,
|
||
ui: &mut egui::Ui,
|
||
label: &str,
|
||
value: &mut Option<String>,
|
||
candidates: &[TextureAssetCandidate],
|
||
) -> bool {
|
||
let current_path = value.clone();
|
||
let dragging_selection = world
|
||
.get_resource::<EditorAssets>()
|
||
.and_then(|assets| assets.dragging_selection().cloned());
|
||
let drop_candidate = dragging_selection
|
||
.as_ref()
|
||
.and_then(|selection| texture_path_from_selection(world, selection));
|
||
let mut selected_path: Option<String> = None;
|
||
let mut clear = false;
|
||
let mut locate = false;
|
||
let mut accepted_drop = false;
|
||
let current_candidate = current_path.as_ref().and_then(|path| {
|
||
candidates
|
||
.iter()
|
||
.find(|candidate| candidate.path == *path)
|
||
.cloned()
|
||
});
|
||
|
||
property_row(ui, label, |ui| {
|
||
let control_width = ui
|
||
.available_width()
|
||
.max(MIN_INLINE_CONTROL_WIDTH.min(ui.available_width().max(1.0)));
|
||
let row_height = 30.0;
|
||
let (rect, _response) =
|
||
ui.allocate_exact_size(egui::vec2(control_width, row_height), egui::Sense::hover());
|
||
let valid_drag = drop_candidate.is_some();
|
||
let row_hovered = ui.rect_contains_pointer(rect);
|
||
let drop_hovered = valid_drag && row_hovered;
|
||
let stroke = if drop_hovered {
|
||
egui::Stroke::new(2.0, egui::Color32::from_rgb(125, 198, 255))
|
||
} else if valid_drag {
|
||
egui::Stroke::new(1.0, egui::Color32::from_rgb(58, 88, 122))
|
||
} else if row_hovered {
|
||
egui::Stroke::new(1.0, egui::Color32::from_rgb(92, 102, 118))
|
||
} else {
|
||
egui::Stroke::new(1.0, BORDER)
|
||
};
|
||
let fill = if drop_hovered {
|
||
egui::Color32::from_rgb(29, 57, 86)
|
||
} else if valid_drag {
|
||
WIDGET_BG.linear_multiply(0.88)
|
||
} else if row_hovered {
|
||
WIDGET_BG.linear_multiply(1.05)
|
||
} else {
|
||
WIDGET_BG.linear_multiply(0.75)
|
||
};
|
||
ui.painter()
|
||
.rect(rect, 4.0, fill, stroke, egui::StrokeKind::Inside);
|
||
if drop_hovered {
|
||
let badge_rect = egui::Rect::from_min_size(
|
||
rect.right_top() + egui::vec2(-82.0, 4.0),
|
||
egui::vec2(74.0, 16.0),
|
||
);
|
||
ui.painter().rect(
|
||
badge_rect,
|
||
3.0,
|
||
egui::Color32::from_rgb(35, 95, 155),
|
||
egui::Stroke::NONE,
|
||
egui::StrokeKind::Inside,
|
||
);
|
||
ui.painter().text(
|
||
badge_rect.center(),
|
||
egui::Align2::CENTER_CENTER,
|
||
"Drop texture",
|
||
egui::FontId::new(10.0, egui::FontFamily::Proportional),
|
||
egui::Color32::from_rgb(225, 241, 255),
|
||
);
|
||
}
|
||
|
||
let mut child = ui.new_child(
|
||
egui::UiBuilder::new()
|
||
.max_rect(rect.shrink2(egui::vec2(6.0, 4.0)))
|
||
.layout(egui::Layout::left_to_right(egui::Align::Center)),
|
||
);
|
||
child.set_clip_rect(rect);
|
||
let preview_size = 22.0;
|
||
let (preview_rect, _preview_response) =
|
||
child.allocate_exact_size(egui::vec2(preview_size, preview_size), egui::Sense::hover());
|
||
child.painter().rect(
|
||
preview_rect,
|
||
3.0,
|
||
PANEL_BG_DARK,
|
||
egui::Stroke::new(1.0, BORDER),
|
||
egui::StrokeKind::Inside,
|
||
);
|
||
if let Some(texture_id) = current_candidate
|
||
.as_ref()
|
||
.and_then(|candidate| candidate.texture_id)
|
||
{
|
||
let uv = egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0));
|
||
child.painter().image(
|
||
texture_id,
|
||
preview_rect.shrink(1.0),
|
||
uv,
|
||
egui::Color32::WHITE,
|
||
);
|
||
} else {
|
||
child.painter().text(
|
||
preview_rect.center(),
|
||
egui::Align2::CENTER_CENTER,
|
||
icons::IMAGE.as_str(),
|
||
egui::FontId::new(12.0, egui::FontFamily::Name("phosphor-regular".into())),
|
||
TEXT_DIM,
|
||
);
|
||
}
|
||
|
||
let action_width = 92.0;
|
||
let text_width = (child.available_width() - action_width).max(1.0);
|
||
child.allocate_ui_with_layout(
|
||
egui::vec2(text_width, 22.0),
|
||
egui::Layout::left_to_right(egui::Align::Center),
|
||
|ui| {
|
||
let display_label = current_candidate
|
||
.as_ref()
|
||
.map(|candidate| candidate.label.as_str())
|
||
.or(current_path.as_deref())
|
||
.unwrap_or("(none)");
|
||
ui.add_sized(
|
||
[text_width, 20.0],
|
||
egui::Label::new(egui::RichText::new(display_label).color(
|
||
if current_path.is_some() {
|
||
TEXT_DIM.linear_multiply(1.45)
|
||
} else {
|
||
TEXT_DIM
|
||
},
|
||
))
|
||
.truncate(),
|
||
);
|
||
},
|
||
);
|
||
|
||
child.allocate_ui_with_layout(
|
||
egui::vec2(action_width, 28.0),
|
||
egui::Layout::right_to_left(egui::Align::Center),
|
||
|ui| {
|
||
let clear_response = ui.add_enabled(
|
||
current_path.is_some(),
|
||
egui::Button::new(phosphor_icon(icons::X, 16.0))
|
||
.frame(false)
|
||
.min_size(egui::vec2(22.0, 22.0)),
|
||
);
|
||
if clear_response.on_hover_text("Clear texture").clicked() {
|
||
clear = true;
|
||
}
|
||
let locate_response = ui.add_enabled(
|
||
current_path.is_some(),
|
||
egui::Button::new(phosphor_icon(icons::CROSSHAIR, 16.0))
|
||
.frame(false)
|
||
.min_size(egui::vec2(22.0, 22.0)),
|
||
);
|
||
if locate_response
|
||
.on_hover_text("Locate in content browser")
|
||
.clicked()
|
||
{
|
||
locate = true;
|
||
}
|
||
if candidates.is_empty() {
|
||
ui.add_enabled(
|
||
false,
|
||
egui::Button::new(phosphor_icon(icons::FOLDER_OPEN, 16.0))
|
||
.frame(false)
|
||
.min_size(egui::vec2(22.0, 22.0)),
|
||
)
|
||
.on_hover_text("No texture assets available");
|
||
} else {
|
||
let menu = ui.menu_button(phosphor_icon(icons::FOLDER_OPEN, 16.0), |ui| {
|
||
ui.set_min_width(240.0);
|
||
for candidate in candidates {
|
||
let selected = current_path.as_deref() == Some(candidate.path.as_str());
|
||
if ui
|
||
.selectable_label(selected, candidate.label.as_str())
|
||
.on_hover_text(candidate.path.as_str())
|
||
.clicked()
|
||
{
|
||
selected_path = Some(candidate.path.clone());
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
menu.response.on_hover_text("Browse textures");
|
||
}
|
||
},
|
||
);
|
||
|
||
if drop_hovered && ui.input(|input| input.pointer.any_released()) {
|
||
if let Some(candidate) = drop_candidate.as_ref() {
|
||
selected_path = Some(candidate.path.clone());
|
||
accepted_drop = true;
|
||
}
|
||
}
|
||
});
|
||
|
||
if locate {
|
||
locate_texture_asset(world, current_path.as_deref(), candidates);
|
||
}
|
||
if accepted_drop {
|
||
if let Some(mut assets) = world.get_resource_mut::<EditorAssets>() {
|
||
assets.clear_drag();
|
||
}
|
||
}
|
||
if clear {
|
||
*value = None;
|
||
return current_path.is_some();
|
||
}
|
||
if let Some(path) = selected_path {
|
||
let changed = current_path.as_deref() != Some(path.as_str());
|
||
*value = Some(path);
|
||
return changed;
|
||
}
|
||
|
||
false
|
||
}
|
||
|
||
fn locate_texture_asset(
|
||
world: &mut World,
|
||
path: Option<&str>,
|
||
candidates: &[TextureAssetCandidate],
|
||
) {
|
||
let Some(path) = path else {
|
||
return;
|
||
};
|
||
let Some(candidate) = candidates.iter().find(|candidate| candidate.path == path) else {
|
||
if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
|
||
scene_io.status = format!("Could not locate texture {path}");
|
||
}
|
||
return;
|
||
};
|
||
|
||
if let Some(mut assets) = world.get_resource_mut::<EditorAssets>() {
|
||
assets.current_folder = candidate.folder_path.clone();
|
||
assets.select(candidate.selection.clone());
|
||
}
|
||
if let Some(mut ui_state) = world.get_resource_mut::<UiState>() {
|
||
let panel_nodes = ui_state.panel_nodes;
|
||
open_and_focus_tab(
|
||
&mut ui_state.dock_state,
|
||
EditorTab::AssetBrowser,
|
||
&panel_nodes,
|
||
);
|
||
}
|
||
}
|
||
|
||
fn option_string_ui(ui: &mut egui::Ui, label: &str, value: &mut Option<String>) -> bool {
|
||
let mut text = value.clone().unwrap_or_default();
|
||
let before = text.clone();
|
||
property_row(ui, label, |ui| {
|
||
ui.horizontal_wrapped(|ui| {
|
||
let clear_width = 52.0;
|
||
let field_width = (ui.available_width() - clear_width - ui.spacing().item_spacing.x)
|
||
.max(MIN_INLINE_CONTROL_WIDTH.min(ui.available_width().max(1.0)))
|
||
.min(TEXT_FIELD_MAX_WIDTH)
|
||
.min(ui.available_width().max(1.0));
|
||
ui.add_sized([field_width, 20.0], egui::TextEdit::singleline(&mut text));
|
||
if ui.button("Clear").clicked() {
|
||
text.clear();
|
||
}
|
||
});
|
||
});
|
||
let changed = before != text;
|
||
*value = if text.trim().is_empty() {
|
||
None
|
||
} else {
|
||
Some(text)
|
||
};
|
||
changed
|
||
}
|