1024 lines
38 KiB
Rust
1024 lines
38 KiB
Rust
//! Animation controller authoring and transient viewport preview controls.
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use bevy::prelude::*;
|
|
use bevy_egui::egui;
|
|
use egui_phosphor_icons::icons;
|
|
use shared::{
|
|
AnimationClipRecord, AnimationControllerDesc, AnimationManifest, AnimationSkeletonRecord,
|
|
AnimationStateDesc, EditorAssetRef, SkinnedMeshRenderer, COMPONENT_ANIMATION_CONTROLLER_DESC,
|
|
};
|
|
|
|
use crate::assets::animation::load_animation_manifest;
|
|
use crate::assets::asset_db::{find_asset_by_id, find_asset_by_path, AssetRegistry};
|
|
use crate::history::set_animation_controller_with_history;
|
|
use crate::ui::inspector::{
|
|
apply_component_card_response, component_card, component_card_context, property_row,
|
|
text_field_width, ComponentCardOptions,
|
|
};
|
|
use crate::ui::theme::{ERROR, SUCCESS, TEXT_DIM, TEXT_MUTED, WARNING};
|
|
use crate::ui::widgets::icon_button_small;
|
|
|
|
#[derive(Resource, Default)]
|
|
pub(crate) struct AnimationInspectorState {
|
|
selected_state: HashMap<Entity, String>,
|
|
scrub_seconds: HashMap<Entity, f32>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum PreviewAction {
|
|
Set(game::animation::AnimationPreviewRequest),
|
|
Stop,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum ClipCompatibility {
|
|
Compatible,
|
|
Unknown,
|
|
Mismatch,
|
|
}
|
|
|
|
impl ClipCompatibility {
|
|
fn label(self) -> &'static str {
|
|
match self {
|
|
Self::Compatible => "Compatible",
|
|
Self::Unknown => "Compatibility unknown",
|
|
Self::Mismatch => "Skeleton mismatch",
|
|
}
|
|
}
|
|
|
|
fn color(self) -> egui::Color32 {
|
|
match self {
|
|
Self::Compatible => SUCCESS,
|
|
Self::Unknown => WARNING,
|
|
Self::Mismatch => ERROR,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn default_controller_for_actor(
|
|
world: &World,
|
|
entity: Entity,
|
|
) -> AnimationControllerDesc {
|
|
manifest_for_actor(world, entity)
|
|
.map(|manifest| controller_from_manifest(&manifest))
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub(crate) fn stop_preview_if_actor(world: &mut World, entity: Entity) {
|
|
let previewing_actor = world
|
|
.get_resource::<game::animation::AnimationPreviewRuntime>()
|
|
.and_then(|runtime| runtime.request.as_ref())
|
|
.is_some_and(|request| request.actor == entity);
|
|
if previewing_actor {
|
|
game::animation::stop_animation_preview(world);
|
|
}
|
|
if let Some(mut state) = world.get_resource_mut::<AnimationInspectorState>() {
|
|
state.selected_state.remove(&entity);
|
|
state.scrub_seconds.remove(&entity);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn animation_controller_inspector_ui(
|
|
world: &mut World,
|
|
ui: &mut egui::Ui,
|
|
entity: Entity,
|
|
) {
|
|
let Some(mut controller) = world.get::<AnimationControllerDesc>(entity).cloned() else {
|
|
return;
|
|
};
|
|
let original = controller.clone();
|
|
let manifest_result = manifest_for_actor(world, entity);
|
|
let manifest = manifest_result.as_ref().ok();
|
|
let referenced_clip_manifests = referenced_clip_manifests(world, &controller, manifest);
|
|
let active_preview = world
|
|
.get_resource::<game::animation::AnimationPreviewRuntime>()
|
|
.and_then(|runtime| runtime.request.clone());
|
|
let stored_selection = world
|
|
.get_resource::<AnimationInspectorState>()
|
|
.and_then(|state| state.selected_state.get(&entity).cloned());
|
|
let stored_scrub = world
|
|
.get_resource::<AnimationInspectorState>()
|
|
.and_then(|state| state.scrub_seconds.get(&entity).copied());
|
|
let mut selected_state = active_preview
|
|
.as_ref()
|
|
.filter(|request| request.actor == entity)
|
|
.map(|request| request.state_id.clone())
|
|
.or(stored_selection)
|
|
.filter(|id| controller.state(id).is_some())
|
|
.or_else(|| {
|
|
controller
|
|
.state(&controller.default_state)
|
|
.map(|state| state.id.clone())
|
|
})
|
|
.or_else(|| controller.states.first().map(|state| state.id.clone()))
|
|
.unwrap_or_default();
|
|
let mut scrub_seconds = active_preview
|
|
.as_ref()
|
|
.filter(|request| request.actor == entity)
|
|
.and_then(|request| request.seek_seconds)
|
|
.or(stored_scrub)
|
|
.unwrap_or_else(|| {
|
|
controller
|
|
.state(&selected_state)
|
|
.map(|state| state.range.start_seconds)
|
|
.unwrap_or(0.0)
|
|
});
|
|
let mut preview_action = None;
|
|
|
|
let card = component_card_context(
|
|
world,
|
|
entity,
|
|
ComponentCardOptions::removable(
|
|
COMPONENT_ANIMATION_CONTROLLER_DESC,
|
|
"Animation Controller",
|
|
icons::FILM_SLATE,
|
|
),
|
|
);
|
|
let card_response = component_card(ui, &card, |ui| {
|
|
manifest_summary(ui, &manifest_result);
|
|
|
|
property_row(ui, "Skeleton", |ui| {
|
|
if let Some(manifest) = manifest {
|
|
let selected = controller
|
|
.skeleton
|
|
.as_ref()
|
|
.map(|skeleton| skeleton.label.as_str())
|
|
.filter(|label| !label.trim().is_empty())
|
|
.unwrap_or("None");
|
|
egui::ComboBox::from_id_salt(("animation_skeleton", entity))
|
|
.selected_text(selected)
|
|
.width(text_field_width(ui))
|
|
.show_ui(ui, |ui| {
|
|
ui.selectable_value(&mut controller.skeleton, None, "None");
|
|
for skeleton in &manifest.skeletons {
|
|
let reference = skeleton_ref(manifest, skeleton);
|
|
ui.selectable_value(
|
|
&mut controller.skeleton,
|
|
Some(reference),
|
|
&skeleton.label,
|
|
);
|
|
}
|
|
});
|
|
} else {
|
|
ui.add_enabled(false, egui::Label::new("Manifest unavailable"));
|
|
}
|
|
});
|
|
|
|
property_row(ui, "Crossfade", |ui| {
|
|
ui.add(
|
|
egui::DragValue::new(&mut controller.default_crossfade_seconds)
|
|
.range(0.0..=5.0)
|
|
.speed(0.01)
|
|
.suffix(" s"),
|
|
);
|
|
});
|
|
|
|
ui.add_space(4.0);
|
|
ui.horizontal(|ui| {
|
|
ui.strong("States");
|
|
ui.label(
|
|
egui::RichText::new(controller.states.len().to_string())
|
|
.small()
|
|
.color(TEXT_MUTED),
|
|
);
|
|
});
|
|
ui.separator();
|
|
|
|
let selected_skeleton = controller.skeleton.clone();
|
|
let mut state_id_counts = HashMap::new();
|
|
for state in &controller.states {
|
|
*state_id_counts.entry(state.id.clone()).or_insert(0_usize) += 1;
|
|
}
|
|
let mut default_state = controller.default_state.clone();
|
|
let mut remove_state = None;
|
|
for (index, state) in controller.states.iter_mut().enumerate() {
|
|
ui.push_id(("animation_state", entity, index), |ui| {
|
|
let heading = if state.label.trim().is_empty() {
|
|
if state.id.trim().is_empty() {
|
|
"Untitled State"
|
|
} else {
|
|
state.id.as_str()
|
|
}
|
|
} else {
|
|
state.label.as_str()
|
|
};
|
|
ui.horizontal(|ui| {
|
|
ui.label(egui::RichText::new(heading).strong());
|
|
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
|
if icon_button_small(ui, icons::TRASH, "Remove state").clicked() {
|
|
remove_state = Some(index);
|
|
}
|
|
if default_state == state.id && !state.id.trim().is_empty() {
|
|
ui.label(egui::RichText::new("DEFAULT").small().color(SUCCESS));
|
|
}
|
|
});
|
|
});
|
|
|
|
property_row(ui, "Name", |ui| {
|
|
ui.add_sized(
|
|
[text_field_width(ui), 20.0],
|
|
egui::TextEdit::singleline(&mut state.label),
|
|
);
|
|
});
|
|
let previous_id = state.id.clone();
|
|
property_row(ui, "State ID", |ui| {
|
|
ui.add_sized(
|
|
[text_field_width(ui), 20.0],
|
|
egui::TextEdit::singleline(&mut state.id),
|
|
);
|
|
});
|
|
if default_state == previous_id && state.id != previous_id {
|
|
default_state.clone_from(&state.id);
|
|
}
|
|
if state.id.trim().is_empty() {
|
|
ui.label(
|
|
egui::RichText::new("State ID is required")
|
|
.small()
|
|
.color(ERROR),
|
|
);
|
|
} else if state_id_counts.get(&previous_id).copied().unwrap_or(0) > 1 {
|
|
ui.label(
|
|
egui::RichText::new("State ID must be unique")
|
|
.small()
|
|
.color(ERROR),
|
|
);
|
|
}
|
|
|
|
property_row(ui, "Clip", |ui| {
|
|
if let Some(manifest) = manifest {
|
|
let selected = if state.clip.label.trim().is_empty() {
|
|
"None"
|
|
} else {
|
|
state.clip.label.as_str()
|
|
};
|
|
egui::ComboBox::from_id_salt("clip")
|
|
.selected_text(selected)
|
|
.width(text_field_width(ui))
|
|
.show_ui(ui, |ui| {
|
|
for clip in &manifest.clips {
|
|
let reference = clip_ref(manifest, clip);
|
|
let suffix = format!("{:.2} s", clip.duration_seconds);
|
|
ui.selectable_value(
|
|
&mut state.clip,
|
|
reference,
|
|
format!("{} {}", clip.label, suffix),
|
|
);
|
|
}
|
|
});
|
|
} else {
|
|
ui.add_enabled(false, egui::Label::new(&state.clip.label));
|
|
}
|
|
});
|
|
|
|
if let Some((primary, clip)) = manifest.and_then(|primary| {
|
|
resolved_clip_for_ref(primary, &referenced_clip_manifests, &state.clip)
|
|
.map(|clip| (primary, clip))
|
|
}) {
|
|
let compatibility =
|
|
clip_compatibility(primary, selected_skeleton.as_ref(), clip);
|
|
ui.label(
|
|
egui::RichText::new(compatibility.label())
|
|
.small()
|
|
.color(compatibility.color()),
|
|
);
|
|
}
|
|
|
|
property_row(ui, "Playback", |ui| {
|
|
ui.horizontal_wrapped(|ui| {
|
|
ui.checkbox(&mut state.looping, "Loop");
|
|
ui.label(egui::RichText::new("Speed").small().color(TEXT_DIM));
|
|
ui.add(
|
|
egui::DragValue::new(&mut state.speed)
|
|
.range(0.01..=8.0)
|
|
.speed(0.01)
|
|
.suffix("x"),
|
|
);
|
|
});
|
|
});
|
|
|
|
let clip_duration = manifest
|
|
.and_then(|manifest| {
|
|
resolved_clip_for_ref(manifest, &referenced_clip_manifests, &state.clip)
|
|
})
|
|
.map(|clip| clip.duration_seconds.max(0.0));
|
|
property_row(ui, "Start", |ui| {
|
|
let max = clip_duration.unwrap_or(86_400.0).max(0.01);
|
|
ui.add(
|
|
egui::DragValue::new(&mut state.range.start_seconds)
|
|
.range(0.0..=max)
|
|
.speed(0.01)
|
|
.suffix(" s"),
|
|
);
|
|
});
|
|
property_row(ui, "End", |ui| {
|
|
ui.horizontal_wrapped(|ui| {
|
|
let mut limited = state.range.end_seconds.is_some();
|
|
if ui.checkbox(&mut limited, "Custom").changed() {
|
|
state.range.end_seconds = limited.then(|| {
|
|
clip_duration
|
|
.unwrap_or(state.range.start_seconds + 1.0)
|
|
.max(state.range.start_seconds + 0.01)
|
|
});
|
|
}
|
|
if let Some(end) = state.range.end_seconds.as_mut() {
|
|
let max = clip_duration
|
|
.unwrap_or(86_400.0)
|
|
.max(state.range.start_seconds + 0.01);
|
|
ui.add(
|
|
egui::DragValue::new(end)
|
|
.range((state.range.start_seconds + 0.01)..=max)
|
|
.speed(0.01)
|
|
.suffix(" s"),
|
|
);
|
|
} else if let Some(duration) = clip_duration {
|
|
ui.label(
|
|
egui::RichText::new(format!("Clip end ({duration:.2} s)"))
|
|
.small()
|
|
.color(TEXT_DIM),
|
|
);
|
|
}
|
|
});
|
|
});
|
|
ui.add_space(4.0);
|
|
ui.separator();
|
|
});
|
|
}
|
|
controller.default_state = default_state;
|
|
|
|
if let Some(index) = remove_state {
|
|
let removed = controller.states.remove(index);
|
|
if controller.default_state == removed.id {
|
|
controller.default_state = controller
|
|
.states
|
|
.first()
|
|
.map(|state| state.id.clone())
|
|
.unwrap_or_default();
|
|
}
|
|
if selected_state == removed.id {
|
|
selected_state = controller
|
|
.states
|
|
.first()
|
|
.map(|state| state.id.clone())
|
|
.unwrap_or_default();
|
|
preview_action = Some(PreviewAction::Stop);
|
|
}
|
|
}
|
|
|
|
if ui
|
|
.add_enabled(
|
|
manifest.is_some_and(|manifest| !manifest.clips.is_empty()),
|
|
egui::Button::new(format!("{} Add State", icons::PLUS.as_str())),
|
|
)
|
|
.on_hover_text("Add an animation state")
|
|
.clicked()
|
|
{
|
|
if let Some(manifest) = manifest {
|
|
if let Some(clip) = preferred_clip(manifest, controller.skeleton.as_ref()) {
|
|
let id = unique_state_id(
|
|
&clip.label,
|
|
controller.states.iter().map(|state| state.id.as_str()),
|
|
);
|
|
controller.states.push(AnimationStateDesc {
|
|
id: id.clone(),
|
|
label: clip.label.clone(),
|
|
clip: clip_ref(manifest, clip),
|
|
..Default::default()
|
|
});
|
|
if controller.default_state.trim().is_empty() {
|
|
controller.default_state.clone_from(&id);
|
|
}
|
|
selected_state = id;
|
|
scrub_seconds = 0.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
let default_choices = controller
|
|
.states
|
|
.iter()
|
|
.map(|state| (state.id.clone(), state_display_name(state).to_string()))
|
|
.collect::<Vec<_>>();
|
|
property_row(ui, "Default state", |ui| {
|
|
let selected = controller
|
|
.state(&controller.default_state)
|
|
.map(state_display_name)
|
|
.unwrap_or("None");
|
|
egui::ComboBox::from_id_salt(("animation_default", entity))
|
|
.selected_text(selected)
|
|
.width(text_field_width(ui))
|
|
.show_ui(ui, |ui| {
|
|
for (id, label) in &default_choices {
|
|
ui.selectable_value(&mut controller.default_state, id.clone(), label);
|
|
}
|
|
});
|
|
});
|
|
|
|
ui.add_space(8.0);
|
|
ui.strong("Preview");
|
|
ui.separator();
|
|
if controller.state(&selected_state).is_none() {
|
|
selected_state = controller
|
|
.state(&controller.default_state)
|
|
.map(|state| state.id.clone())
|
|
.or_else(|| controller.states.first().map(|state| state.id.clone()))
|
|
.unwrap_or_default();
|
|
}
|
|
let preview_choices = controller
|
|
.states
|
|
.iter()
|
|
.map(|state| (state.id.clone(), state_display_name(state).to_string()))
|
|
.collect::<Vec<_>>();
|
|
let runtime_supported = manifest.is_some_and(|manifest| manifest.runtime_supported);
|
|
let preview_valid = controller.state(&selected_state).is_some_and(|state| {
|
|
state.clip.is_resolved()
|
|
&& manifest.is_some_and(|manifest| {
|
|
resolved_clip_for_ref(manifest, &referenced_clip_manifests, &state.clip)
|
|
.is_some_and(|clip| {
|
|
clip_compatibility(manifest, controller.skeleton.as_ref(), clip)
|
|
!= ClipCompatibility::Mismatch
|
|
})
|
|
})
|
|
});
|
|
property_row(ui, "State", |ui| {
|
|
let selected = controller
|
|
.state(&selected_state)
|
|
.map(state_display_name)
|
|
.unwrap_or("None");
|
|
egui::ComboBox::from_id_salt(("animation_preview_state", entity))
|
|
.selected_text(selected)
|
|
.width(text_field_width(ui))
|
|
.show_ui(ui, |ui| {
|
|
for (id, label) in &preview_choices {
|
|
if ui
|
|
.selectable_value(&mut selected_state, id.clone(), label)
|
|
.clicked()
|
|
{
|
|
scrub_seconds = controller
|
|
.state(id)
|
|
.map(|state| state.range.start_seconds)
|
|
.unwrap_or(0.0);
|
|
preview_action = Some(PreviewAction::Set(
|
|
game::animation::AnimationPreviewRequest {
|
|
actor: entity,
|
|
state_id: id.clone(),
|
|
seek_seconds: Some(scrub_seconds),
|
|
playing: false,
|
|
},
|
|
));
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
let active_for_actor = active_preview
|
|
.as_ref()
|
|
.is_some_and(|request| request.actor == entity);
|
|
let active_playing = active_preview.as_ref().is_some_and(|request| {
|
|
request.actor == entity && request.state_id == selected_state && request.playing
|
|
});
|
|
property_row(ui, "Transport", |ui| {
|
|
ui.horizontal_wrapped(|ui| {
|
|
let icon = if active_playing {
|
|
icons::PAUSE
|
|
} else {
|
|
icons::PLAY
|
|
};
|
|
let label = if active_playing { "Pause" } else { "Play" };
|
|
if ui
|
|
.add_enabled(
|
|
runtime_supported && preview_valid,
|
|
egui::Button::new(format!("{} {label}", icon.as_str())),
|
|
)
|
|
.clicked()
|
|
{
|
|
preview_action = Some(PreviewAction::Set(
|
|
game::animation::AnimationPreviewRequest {
|
|
actor: entity,
|
|
state_id: selected_state.clone(),
|
|
seek_seconds: Some(scrub_seconds),
|
|
playing: !active_playing,
|
|
},
|
|
));
|
|
}
|
|
if ui
|
|
.add_enabled(
|
|
active_for_actor,
|
|
egui::Button::new(format!("{} Stop", icons::STOP.as_str())),
|
|
)
|
|
.clicked()
|
|
{
|
|
preview_action = Some(PreviewAction::Stop);
|
|
}
|
|
});
|
|
});
|
|
|
|
if let Some(state) = controller.state(&selected_state) {
|
|
let clip_end = manifest
|
|
.and_then(|manifest| {
|
|
resolved_clip_for_ref(manifest, &referenced_clip_manifests, &state.clip)
|
|
})
|
|
.map(|clip| clip.duration_seconds)
|
|
.unwrap_or(state.range.start_seconds + 1.0);
|
|
let end = state
|
|
.range
|
|
.end_seconds
|
|
.unwrap_or(clip_end)
|
|
.max(state.range.start_seconds + 0.01);
|
|
scrub_seconds = scrub_seconds.clamp(state.range.start_seconds, end);
|
|
property_row(ui, "Time", |ui| {
|
|
ui.horizontal(|ui| {
|
|
let response = ui.add_enabled(
|
|
runtime_supported && preview_valid,
|
|
egui::Slider::new(&mut scrub_seconds, state.range.start_seconds..=end)
|
|
.show_value(false),
|
|
);
|
|
ui.label(
|
|
egui::RichText::new(format!("{scrub_seconds:.2} / {end:.2} s"))
|
|
.small()
|
|
.color(TEXT_DIM),
|
|
);
|
|
if response.changed() {
|
|
preview_action = Some(PreviewAction::Set(
|
|
game::animation::AnimationPreviewRequest {
|
|
actor: entity,
|
|
state_id: selected_state.clone(),
|
|
seek_seconds: Some(scrub_seconds),
|
|
playing: false,
|
|
},
|
|
));
|
|
}
|
|
});
|
|
});
|
|
}
|
|
if manifest.is_some_and(|manifest| !manifest.runtime_supported) {
|
|
ui.label(
|
|
egui::RichText::new("Preview unavailable for this source format")
|
|
.small()
|
|
.color(WARNING),
|
|
);
|
|
}
|
|
});
|
|
|
|
controller.default_crossfade_seconds = controller.default_crossfade_seconds.max(0.0);
|
|
for state in &mut controller.states {
|
|
state.speed = state.speed.max(0.01);
|
|
state.range.start_seconds = state.range.start_seconds.max(0.0);
|
|
if let Some(end) = state.range.end_seconds.as_mut() {
|
|
*end = end.max(state.range.start_seconds + 0.01);
|
|
}
|
|
}
|
|
|
|
let changed = controller != original;
|
|
if changed {
|
|
set_animation_controller_with_history(world, entity, controller.clone());
|
|
}
|
|
let active_state_still_exists = active_preview
|
|
.as_ref()
|
|
.filter(|request| request.actor == entity)
|
|
.is_none_or(|request| controller.state(&request.state_id).is_some());
|
|
if !active_state_still_exists {
|
|
game::animation::stop_animation_preview(world);
|
|
}
|
|
match preview_action {
|
|
Some(PreviewAction::Set(request)) if controller.state(&request.state_id).is_some() => {
|
|
if world
|
|
.get_resource::<game::animation::AnimationPreviewRuntime>()
|
|
.is_none()
|
|
{
|
|
set_status(world, "Animation preview failed: runtime is unavailable");
|
|
} else if let Err(error) = game::animation::set_animation_preview(world, request) {
|
|
set_status(world, format!("Animation preview failed: {error}"));
|
|
}
|
|
}
|
|
Some(PreviewAction::Set(_)) | Some(PreviewAction::Stop) => {
|
|
stop_preview_if_actor(world, entity);
|
|
}
|
|
None => {}
|
|
}
|
|
if let Some(mut state) = world.get_resource_mut::<AnimationInspectorState>() {
|
|
if selected_state.is_empty() {
|
|
state.selected_state.remove(&entity);
|
|
} else {
|
|
state.selected_state.insert(entity, selected_state);
|
|
}
|
|
state.scrub_seconds.insert(entity, scrub_seconds);
|
|
}
|
|
apply_component_card_response(world, entity, card_response);
|
|
}
|
|
|
|
fn manifest_summary(ui: &mut egui::Ui, manifest: &Result<AnimationManifest, String>) {
|
|
match manifest {
|
|
Ok(manifest) => {
|
|
let color = if manifest.runtime_supported {
|
|
SUCCESS
|
|
} else {
|
|
WARNING
|
|
};
|
|
ui.horizontal_wrapped(|ui| {
|
|
ui.label(
|
|
egui::RichText::new(format!(
|
|
"{} | {} rig{} | {} clip{}",
|
|
manifest.source.format.to_ascii_uppercase(),
|
|
manifest.skeletons.len(),
|
|
if manifest.skeletons.len() == 1 {
|
|
""
|
|
} else {
|
|
"s"
|
|
},
|
|
manifest.clips.len(),
|
|
if manifest.clips.len() == 1 { "" } else { "s" },
|
|
))
|
|
.small()
|
|
.color(color),
|
|
);
|
|
});
|
|
if let Some(diagnostic) = manifest.diagnostics.first() {
|
|
ui.label(
|
|
egui::RichText::new(&diagnostic.message)
|
|
.small()
|
|
.color(WARNING),
|
|
)
|
|
.on_hover_text(&diagnostic.repair);
|
|
}
|
|
}
|
|
Err(error) => {
|
|
ui.label(
|
|
egui::RichText::new("Animation manifest unavailable")
|
|
.small()
|
|
.color(ERROR),
|
|
)
|
|
.on_hover_text(error);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn manifest_for_actor(world: &World, entity: Entity) -> Result<AnimationManifest, String> {
|
|
let model = world
|
|
.get::<SkinnedMeshRenderer>(entity)
|
|
.ok_or_else(|| "actor has no SkinnedMeshRenderer".to_string())?;
|
|
let registry = world
|
|
.get_resource::<AssetRegistry>()
|
|
.ok_or_else(|| "asset registry is unavailable".to_string())?;
|
|
let normalized = model.path.trim_start_matches("./");
|
|
let with_assets = (!normalized.starts_with("assets/")).then(|| format!("assets/{normalized}"));
|
|
let without_assets = normalized.strip_prefix("assets/");
|
|
let record = (!model.asset_id.trim().is_empty())
|
|
.then(|| find_asset_by_id(registry, &model.asset_id))
|
|
.flatten()
|
|
.or_else(|| find_asset_by_path(registry, normalized))
|
|
.or_else(|| {
|
|
with_assets
|
|
.as_deref()
|
|
.and_then(|path| find_asset_by_path(registry, path))
|
|
})
|
|
.or_else(|| without_assets.and_then(|path| find_asset_by_path(registry, path)))
|
|
.ok_or_else(|| format!("model `{}` is not indexed", model.path))?;
|
|
let path = record
|
|
.import_settings
|
|
.animation_manifest_path
|
|
.as_deref()
|
|
.ok_or_else(|| format!("model `{}` has no animation manifest", model.path))?;
|
|
load_animation_manifest(path)
|
|
}
|
|
|
|
fn referenced_clip_manifests(
|
|
world: &World,
|
|
controller: &AnimationControllerDesc,
|
|
primary: Option<&AnimationManifest>,
|
|
) -> HashMap<String, AnimationManifest> {
|
|
let Some(registry) = world.get_resource::<AssetRegistry>() else {
|
|
return HashMap::new();
|
|
};
|
|
let primary_id = primary.map(|manifest| manifest.asset_id.as_str());
|
|
let mut manifests = HashMap::new();
|
|
for asset_id in controller
|
|
.states
|
|
.iter()
|
|
.map(|state| state.clip.asset_id.as_str())
|
|
.filter(|asset_id| !asset_id.trim().is_empty() && Some(*asset_id) != primary_id)
|
|
{
|
|
if manifests.contains_key(asset_id) {
|
|
continue;
|
|
}
|
|
let Some(record) = find_asset_by_id(registry, asset_id) else {
|
|
continue;
|
|
};
|
|
let Some(path) = record.import_settings.animation_manifest_path.as_deref() else {
|
|
continue;
|
|
};
|
|
if let Ok(manifest) = load_animation_manifest(path) {
|
|
manifests.insert(asset_id.to_string(), manifest);
|
|
}
|
|
}
|
|
manifests
|
|
}
|
|
|
|
fn controller_from_manifest(manifest: &AnimationManifest) -> AnimationControllerDesc {
|
|
let skeleton = manifest
|
|
.skeletons
|
|
.first()
|
|
.map(|record| skeleton_ref(manifest, record));
|
|
let clip = preferred_clip(manifest, skeleton.as_ref());
|
|
let states = clip
|
|
.map(|clip| {
|
|
let id = unique_state_id(&clip.label, std::iter::empty::<&str>());
|
|
vec![AnimationStateDesc {
|
|
id,
|
|
label: clip.label.clone(),
|
|
clip: clip_ref(manifest, clip),
|
|
..Default::default()
|
|
}]
|
|
})
|
|
.unwrap_or_default();
|
|
let default_state = states
|
|
.first()
|
|
.map(|state| state.id.clone())
|
|
.unwrap_or_default();
|
|
AnimationControllerDesc {
|
|
skeleton,
|
|
states,
|
|
default_state,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
fn skeleton_ref(
|
|
manifest: &AnimationManifest,
|
|
skeleton: &AnimationSkeletonRecord,
|
|
) -> EditorAssetRef {
|
|
EditorAssetRef::new(
|
|
manifest.asset_id.clone(),
|
|
skeleton.id.clone(),
|
|
skeleton.label.clone(),
|
|
)
|
|
.with_source_path(manifest.source.path.clone())
|
|
}
|
|
|
|
fn clip_ref(manifest: &AnimationManifest, clip: &AnimationClipRecord) -> EditorAssetRef {
|
|
EditorAssetRef::new(
|
|
manifest.asset_id.clone(),
|
|
clip.id.clone(),
|
|
clip.label.clone(),
|
|
)
|
|
.with_source_path(manifest.source.path.clone())
|
|
}
|
|
|
|
fn clip_for_ref<'a>(
|
|
manifest: &'a AnimationManifest,
|
|
reference: &EditorAssetRef,
|
|
) -> Option<&'a AnimationClipRecord> {
|
|
if manifest.asset_id != reference.asset_id {
|
|
return None;
|
|
}
|
|
manifest
|
|
.clips
|
|
.iter()
|
|
.find(|clip| clip.id == reference.sub_asset_id)
|
|
}
|
|
|
|
fn resolved_clip_for_ref<'a>(
|
|
primary: &'a AnimationManifest,
|
|
referenced: &'a HashMap<String, AnimationManifest>,
|
|
reference: &EditorAssetRef,
|
|
) -> Option<&'a AnimationClipRecord> {
|
|
if primary.asset_id == reference.asset_id {
|
|
clip_for_ref(primary, reference)
|
|
} else {
|
|
referenced
|
|
.get(&reference.asset_id)
|
|
.and_then(|manifest| clip_for_ref(manifest, reference))
|
|
}
|
|
}
|
|
|
|
fn preferred_clip<'a>(
|
|
manifest: &'a AnimationManifest,
|
|
skeleton: Option<&EditorAssetRef>,
|
|
) -> Option<&'a AnimationClipRecord> {
|
|
manifest
|
|
.clips
|
|
.iter()
|
|
.find(|clip| clip_compatibility(manifest, skeleton, clip) == ClipCompatibility::Compatible)
|
|
.or_else(|| {
|
|
manifest.clips.iter().find(|clip| {
|
|
clip_compatibility(manifest, skeleton, clip) == ClipCompatibility::Unknown
|
|
})
|
|
})
|
|
}
|
|
|
|
fn clip_compatibility(
|
|
manifest: &AnimationManifest,
|
|
skeleton: Option<&EditorAssetRef>,
|
|
clip: &AnimationClipRecord,
|
|
) -> ClipCompatibility {
|
|
let Some(skeleton) = skeleton else {
|
|
return ClipCompatibility::Unknown;
|
|
};
|
|
let Some(skeleton) = manifest
|
|
.skeletons
|
|
.iter()
|
|
.find(|record| record.id == skeleton.sub_asset_id)
|
|
else {
|
|
return ClipCompatibility::Unknown;
|
|
};
|
|
let Some(target) = clip.target_skeleton_signature.as_ref() else {
|
|
return ClipCompatibility::Unknown;
|
|
};
|
|
if target == &skeleton.signature {
|
|
ClipCompatibility::Compatible
|
|
} else {
|
|
ClipCompatibility::Mismatch
|
|
}
|
|
}
|
|
|
|
fn unique_state_id<'a>(label: &str, existing: impl Iterator<Item = &'a str>) -> String {
|
|
let existing = existing.collect::<Vec<_>>();
|
|
let mut base = String::new();
|
|
for character in label.chars() {
|
|
if character.is_ascii_alphanumeric() {
|
|
base.push(character.to_ascii_lowercase());
|
|
} else if !base.ends_with('_') {
|
|
base.push('_');
|
|
}
|
|
}
|
|
let base = base.trim_matches('_');
|
|
let base = if base.is_empty() { "state" } else { base };
|
|
if !existing.contains(&base) {
|
|
return base.to_string();
|
|
}
|
|
(2..)
|
|
.map(|suffix| format!("{base}_{suffix}"))
|
|
.find(|candidate| !existing.iter().any(|id| *id == candidate))
|
|
.expect("unbounded state ID suffix search must find an ID")
|
|
}
|
|
|
|
fn state_display_name(state: &AnimationStateDesc) -> &str {
|
|
if state.label.trim().is_empty() {
|
|
state.id.as_str()
|
|
} else {
|
|
state.label.as_str()
|
|
}
|
|
}
|
|
|
|
fn set_status(world: &mut World, status: impl Into<String>) {
|
|
if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
|
|
scene_io.set_status(status);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use shared::{AnimationManifestSource, AnimationSkeletonSignature, AnimationSourceFingerprint};
|
|
|
|
fn manifest() -> AnimationManifest {
|
|
let signature = AnimationSkeletonSignature::new("rig-a");
|
|
AnimationManifest {
|
|
schema_version: 1,
|
|
asset_id: "model-id".into(),
|
|
label: "Robot".into(),
|
|
default_animation_clip_id: None,
|
|
source: AnimationManifestSource {
|
|
path: "assets/models/robot.glb".into(),
|
|
format: "glb".into(),
|
|
fingerprint: AnimationSourceFingerprint {
|
|
byte_len: 42,
|
|
content_hash: "hash".into(),
|
|
},
|
|
dependencies: Vec::new(),
|
|
},
|
|
runtime_supported: true,
|
|
skeletons: vec![AnimationSkeletonRecord {
|
|
id: "animation:skeleton:0:rig".into(),
|
|
label: "Rig".into(),
|
|
source_index: 0,
|
|
signature: signature.clone(),
|
|
joint_paths: vec!["Root".into()],
|
|
}],
|
|
clips: vec![
|
|
AnimationClipRecord {
|
|
id: "animation:clip:0:idle".into(),
|
|
label: "Idle Loop".into(),
|
|
source_index: 0,
|
|
duration_seconds: 2.0,
|
|
target_skeleton_signature: Some(signature),
|
|
events: Vec::new(),
|
|
},
|
|
AnimationClipRecord {
|
|
id: "animation:clip:1:other".into(),
|
|
label: "Other".into(),
|
|
source_index: 1,
|
|
duration_seconds: 1.0,
|
|
target_skeleton_signature: Some(AnimationSkeletonSignature::new("rig-b")),
|
|
events: Vec::new(),
|
|
},
|
|
],
|
|
diagnostics: Vec::new(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn manifest_defaults_select_a_compatible_rig_and_clip() {
|
|
let manifest = manifest();
|
|
let controller = controller_from_manifest(&manifest);
|
|
assert_eq!(controller.skeleton.as_ref().unwrap().label, "Rig");
|
|
assert_eq!(controller.states.len(), 1);
|
|
assert_eq!(controller.states[0].id, "idle_loop");
|
|
assert_eq!(controller.default_state, "idle_loop");
|
|
assert_eq!(
|
|
controller.states[0].clip.source_path.as_deref(),
|
|
Some("assets/models/robot.glb")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn state_ids_are_stable_and_unique() {
|
|
assert_eq!(
|
|
unique_state_id("Idle Loop", std::iter::empty()),
|
|
"idle_loop"
|
|
);
|
|
assert_eq!(
|
|
unique_state_id("Idle Loop", ["idle_loop"].into_iter()),
|
|
"idle_loop_2"
|
|
);
|
|
assert_eq!(
|
|
unique_state_id("---", ["state", "state_2"].into_iter()),
|
|
"state_3"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn compatibility_distinguishes_matching_and_foreign_rigs() {
|
|
let manifest = manifest();
|
|
let skeleton = skeleton_ref(&manifest, &manifest.skeletons[0]);
|
|
assert_eq!(
|
|
clip_compatibility(&manifest, Some(&skeleton), &manifest.clips[0]),
|
|
ClipCompatibility::Compatible
|
|
);
|
|
assert_eq!(
|
|
clip_compatibility(&manifest, Some(&skeleton), &manifest.clips[1]),
|
|
ClipCompatibility::Mismatch
|
|
);
|
|
assert_eq!(
|
|
clip_compatibility(&manifest, None, &manifest.clips[0]),
|
|
ClipCompatibility::Unknown
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn clip_lookup_uses_stable_parent_asset_identity() {
|
|
let primary = manifest();
|
|
let mut foreign = manifest();
|
|
foreign.asset_id = "foreign-model-id".into();
|
|
foreign.clips[0].label = "Foreign Idle".into();
|
|
let reference = EditorAssetRef::new(
|
|
foreign.asset_id.clone(),
|
|
foreign.clips[0].id.clone(),
|
|
foreign.clips[0].label.clone(),
|
|
);
|
|
let referenced = HashMap::from([(foreign.asset_id.clone(), foreign)]);
|
|
|
|
assert!(clip_for_ref(&primary, &reference).is_none());
|
|
assert_eq!(
|
|
resolved_clip_for_ref(&primary, &referenced, &reference)
|
|
.map(|clip| clip.label.as_str()),
|
|
Some("Foreign Idle")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn preview_does_not_dirty_authored_data_or_history() {
|
|
let mut world = World::new();
|
|
world.init_resource::<game::animation::AnimationPreviewRuntime>();
|
|
world.init_resource::<crate::history::EditorHistory>();
|
|
world.init_resource::<crate::scene_io::SceneIo>();
|
|
let controller = controller_from_manifest(&manifest());
|
|
let actor = world.spawn(controller.clone()).id();
|
|
|
|
game::animation::set_animation_preview(
|
|
&mut world,
|
|
game::animation::AnimationPreviewRequest {
|
|
actor,
|
|
state_id: controller.default_state.clone(),
|
|
seek_seconds: Some(0.5),
|
|
playing: true,
|
|
},
|
|
)
|
|
.unwrap();
|
|
game::animation::stop_animation_preview(&mut world);
|
|
|
|
assert_eq!(
|
|
world.get::<AnimationControllerDesc>(actor),
|
|
Some(&controller)
|
|
);
|
|
assert_eq!(
|
|
world
|
|
.resource::<crate::history::EditorHistory>()
|
|
.undo_depth(),
|
|
0
|
|
);
|
|
assert!(!world.resource::<crate::scene_io::SceneIo>().dirty);
|
|
}
|
|
}
|