//! 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, scrub_seconds: HashMap, } #[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::() .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::() { 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::(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::() .and_then(|runtime| runtime.request.clone()); let stored_selection = world .get_resource::() .and_then(|state| state.selected_state.get(&entity).cloned()); let stored_scrub = world .get_resource::() .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::>(); 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::>(); 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::() .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::() { 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) { 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 { let model = world .get::(entity) .ok_or_else(|| "actor has no SkinnedMeshRenderer".to_string())?; let registry = world .get_resource::() .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 { let Some(registry) = world.get_resource::() 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, 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) -> String { let existing = existing.collect::>(); 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) { if let Some(mut scene_io) = world.get_resource_mut::() { 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::(); world.init_resource::(); world.init_resource::(); 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::(actor), Some(&controller) ); assert_eq!( world .resource::() .undo_depth(), 0 ); assert!(!world.resource::().dirty); } }