Two or more AnimationPlayer (3D)

[thmsgntz]

Hello! :)
I'm having trouble to handle multiple AnimationPlayer objects.
I am perfectly ok with only one AnimationPlayer, but with more than one...

Right now I have a Bundle for spawning creatures:

#[derive(Bundle)]
pub struct Creature  {
    pub hashmap_animations: HashMapAnimations,
    
    /*
    other stuff like health, transform etc.    
     */
}

#[derive(Component)]
pub struct HashMapAnimations {
  pub current_animation_id: i32,
  pub hash_animations: HashMap<i32, SingleAnimation>,
}

pub struct SingleAnimation {
  pub id: i32,
  pub handle: Handle<AnimationClip>,
  pub duration: f32,
  pub is_repeatable: bool,
}

But when I want to update their animation, I would do :

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
  // spawn creature 1
  let mut hash_animations_1 = creatures::HashMapAnimations::default();
  
  hash_animations_1.add_animation(
    1,
    asset_server.load("models/creature_1/scene.gltf#Animation1"),
    1.58,
    true,
  );
  
  /* add other animations */

  commands
          .spawn()
          .insert_bundle(creatures::Creature {
            hashmap_animations: hash_animations_1,
            /*
            other stuff
            */
          })
          .with_children(|parent| {
            // bevy 0.7 style 
            parent.spawn_scene(asset_server.load("models/creature_1/scene.gltf#Scene0"));
          });

    /* spawn others creatures the same way*/
}

fn update_animation(
    mut animation_players: Query<(Entity, &mut AnimationPlayer)>,
    mut query_creature: Query<&HashMapAnimations>,
) {
    for (e, mut player) in animation_players.iter_mut() {
        // how do I know if player is handling animations for creature one or two??

         if let Ok(mut map_creature) = query_creature.get_single_mut() {
                if let Some(animation) = map_creature.get(ind) {
                    player.play(animation.handle.clone_weak()).repeat();
                }
          }
     }
} 

Thanks!

[thmsgntz]

EDIT : see @pinkponk 's answer below

---

Maybe I can clarify my question: from what I understood:

1. When loaded a scene (asset_server.load(&scene_path)) from a gltf file, a new AnimationPlayer is created.

2. If I load two scenes, one for creature 1 and one for creature 2 (different GLTF files, so different animations), two AnimationPlayers will exist in the World

3. To update the animation of creature 1, I need to query its AnimationPlayer:

fn start_animation(
    mut player: Query<&mut AnimationPlayer>
    [...]
) {...}

4. But can I know if this AnimationPlayer is the one from creature 1 or 2? Is there a way to mark them?

5. If I load an AnimationClip from creature 1 in the AnimationPlayer of creature 2, I get this error.

Am I misunderstanding something? All the examples I found in bevy/examples use only one GLTF scene 😢

Thank you so much!

[thmsgntz]

You mean I can tag a AnimationPlayer entity even if I am not the one creating it? Apparently the crate bevy_animation creates it when loading a GLTF scene (here)

I know how to differentiate between my two creatures. But as I am not the one spawning the AnimationPlayer, I do not know how to tie an AnimationPlayer with a creature entity.

Sorry if I sound stupid, maybe I am missing something really obvious

[thmsgntz]

More basically, if I take the example animated_fox.rs (still v0.7.0):

I spawn the fox GLTF and a skeleton GLTF, and my problem appears in the setup_scene_once_loaded because I do not know how to differentiate which AnimationPlayer is associated with which AnimationClip. This code does not work:

struct Animations(Vec<Handle<AnimationClip>>);

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut scene_spawner: ResMut<SceneSpawner>,
) {

    commands.insert_resource(Animations(vec![
        asset_server.load("models/Fox.glb#Animation2"),
        asset_server.load("models/Fox.glb#Animation1"),
        asset_server.load("models/Fox.glb#Animation0"),
    ]));

    scene_spawner.spawn(asset_server.load("models/Fox.glb#Scene0"));

    commands.insert_resource(Animations(vec![
        asset_server.load("models/skeleton/scene.gltf#Animation1"),
        asset_server.load("models/skeleton/scene.gltf#Animation2"),
        asset_server.load("models/skeleton/scene.gltf#Animation3"),
    ]));

    scene_spawner.spawn(asset_server.load("models/skeleton/scene.gltf#Scene0"));
}

fn setup_scene_once_loaded(
    animations: Res<Animations>,
    mut animation_players: Query<(Entity, &mut AnimationPlayer)>,
    mut done: Local<u8>,
) {
    if *done < 2 {
        for (entity, mut player) in animation_players.iter_mut() {
              player.play(animations.0[0].clone_weak()).repeat();   // <-- not working
              *done += 1;
        }
    }
}

[pinkponk]

I had the exact same problem. I now have 100s of creatures running around. Certainly not the best solution but maybe it can be of some help for you, I did this:

#[derive(Component)]
pub struct AnimationEntityLink(pub Entity);

fn get_top_parent(mut curr_entity: Entity, parent_query: &Query<&Parent>) -> Entity {
    //Loop up all the way to the top parent
    loop {
        if let Ok(parent) = parent_query.get(curr_entity) {
            curr_entity = parent.get();
        } else {
            break;
        }
    }
    curr_entity
}

pub fn link_animations(
    player_query: Query<Entity, Added<AnimationPlayer>>,
    parent_query: Query<&Parent>,
    animations_entity_link_query: Query<&AnimationEntityLink>,
    mut commands: Commands,
) {
    // Get all the Animation players which can be deep and hidden in the heirachy
    for entity in player_query.iter() {
        let top_entity = get_top_parent(entity, &parent_query);

        // If the top parent has an animation config ref then link the player to the config
        if animations_entity_link_query.get(top_entity).is_ok() {
            warn!("Problem with multiple animationsplayers for the same top parent");
        } else {
            commands
                .entity(top_entity)
                .insert(AnimationEntityLink(entity.clone()));
        }
    }
}

Then I have something like this for changing and adjusting the animations

pub fn sync_animation_to_velocity(
    mut player_query: Query<&mut AnimationPlayer>,
    mut query: Query<(&Movable, &mut AnimationConfig, &AnimationEntityLink), Changed<Movable>>,
    animations: Res<Animations>,
    game_speed: Res<GameSpeed>,
) {
    for (movable, mut animation_config, animation_entity) in query.iter_mut() {
        if let Ok(mut player) = player_query.get_mut(animation_entity.0) {
//Stuff
        }
     }
}

[thmsgntz]

Hello @pinkponk !
Nice hack, I successfully implemented your solution and it works.

I'm not sure if this is the intended way of using multiples AnimationPlayers, but this is a solution! Maybe @mockersf has an opinion (or any other Bevy's devs)?

Thank you so muck @pinkponk, I will use your solution for now!

[pinkponk]

Glad that it could be of use :) @thmsgntz If you find a better way of doing it please send me a ping

[johnnyw]

I ran into a similar issue, trying to independently set animations for multiple instances of the same scene. The first approach seems the most intuitive, and the eventual solution (traversing the entity hierarchy and creating a special link component) seems kind of obtuse. It makes me wonder if I'm missing something about the design of the AnimationPlayer component, or if the current design just doesn't support multiple independent animations that well.

[johnnyw]

In my specific case I had two instances of the same animated mesh that I wanted to apply different animations to, rather than two completely different meshes and animations, but I think this solution or something similar will work in general:

#[derive(Component)]
struct AnimationIndex {
    value: usize,
}

fn init_animation(
    animations: Res<Animations>,
    mut animation_players: Query<&mut AnimationPlayer>,
    animation_indices: Query<(Entity, &AnimationIndex), With<AnimationIndex>>,
    children: Query<&Children>,
    mut done: Local<usize>,
) {
    if *done < animation_indices.iter().len() {
        for (animation_index_entity, animation_index) in &animation_indices {
            for entity in children.iter_descendants(animation_index_entity) {
                if let Ok(mut animation_player) = animation_players.get_mut(entity) {
                    animation_player.play(animations.0[animation_index.value].clone_weak()).repeat();
                    *done += 1;
                }
            }
        }
    }
}

I'm basically cribbing off of the Animated Fox and Update GLTF Scene examples. The AnimationIndex component is attached to the same entity as the scene bundle, and when this system runs it fetches those entities and digs into their children to find and set the AnimationPlayer component. The done: Local<usize> business is another extension of the animated fox demo setting the animations as soon as the scene is loaded, using the number of AnimationIndex-having entities instead of a bool. Maybe I can get something similar working for in-game transitions, perhaps using events or something.

[thmsgntz]

@adamgiacomelli looks great!

There is work in progress on this subject, you can have a look at this #8357 and #8996.
Hope this can help :)

[SnowdenWintermute]

I spent about 4-5 days trying to figure out how to animate specific models before finding this post. I used the marked solution and it works well. I think it is faster to iterate to the top parent than to search through children. I got so into this problem I created a video guide about it, using @pinkponk 's solution:

https://www.youtube.com/watch?v=ibbYSDiFK74

But ultimately I hope this method becomes obsolete soon because it is not ergonomic at all that this is the way to specify something you want to animate.

[rajsahae]

I have a similar situation but I'm loading a Scene and it has 2 animations, for different meshes in the scene.

Simplified example that uses bevy_asset_loader but you could load this manually. I have piggybacked my approach off @pinkponk 's solution but with a very gross assumption to play the right clip with the right player. I'm not sure how else to handle this?

Ideally, is there a way to know which clip is associated with a given Entity? Is that a Query I can do? There must be some link because given the wrong clip, bevy_animation does complain with Animation player on 12v1 did not match any entity paths. I suppose I should look at the source code to see how it determines this, it could probably tell me what to do.

EDITS

Looks like it retrieves the AnimationClip from assets, gets the path, and then walks down the entity Children to find that path but it's not a trivial call or search to make, it seems.

Could I retrieve the AnimationClip and use AnimationClip::compatible_with in some way?

#[derive(Clone, Default, Debug, States, Hash, PartialEq, Eq)]
enum AppState {
    #[default]
    Loading,
    Running,
}

#[derive(Component, Deref, DerefMut)]
struct MyTimer(Timer);

#[derive(Component, Deref, DerefMut, Default)]
struct AnimationLinks(Vec<AnimationEntityLink>);

#[derive(Bundle)]
struct MyBundle {
    links: AnimationLinks,
    scene: SceneBundle,
    timer: MyTimer,
}

impl Default for MyTimer {
    fn default() -> Self {
        Self(Timer::from_seconds(10.0, TimerMode::Repeating))
    }
}

#[derive(AssetCollection, Resource, Default)]
pub struct MyAssets {
    #[asset(path = "model.glb#Scene0")]
    scene: Handle<Scene>,
    #[asset(path = "model.glb#Animation0")]
    action_one: Handle<AnimationClip>,
    #[asset(path = "model.glb#Animation1")]
    action_two: Handle<AnimationClip>,
}

impl MyBundle {
    fn new(scene: Handle<Scene>) -> Self {
        Self {
            links: AnimationLinks::default(),
            scene: SceneBundle {
                scene,
                ..Default::default()
            },
            timer: MyTimer::default(),
        }
    }
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(ClearColor(Color::ALICE_BLUE))
        .insert_resource(AmbientLight {
            color: Color::WHITE,
            brightness: OVERCAST_DAY,
        })
        .init_state::<AppState>()
        .add_loading_state(
            LoadingState::new(AppState::Loading)
                .continue_to_state(AppState::Running)
                .load_collection::<MyAssets>(),
        )
        .add_systems(OnExit(AppState::Loading), load)
        .add_systems(
            Update,
            (link_animations, animate).run_if(in_state(AppState::Running)),
        )
        .run();
}

fn load(mut commands: Commands, assets: Res<MyAssets>) {
    commands.spawn(Camera3dBundle {
        transform: Transform::from_xyz(0., 3., 10.).looking_at(Vec3::new(1.5, 1., 0.), Vec3::Y),
        ..Default::default()
    });

    commands.spawn(MyBundle::new(assets.scene.clone());
}

#[derive(Component, Deref)]
pub struct AnimationEntityLink(Entity);

fn get_top_parent(mut curr_entity: Entity, parent_query: &Query<&Parent>) -> Entity {
    //Loop up all the way to the top parent
    loop {
        if let Ok(parent) = parent_query.get(curr_entity) {
            curr_entity = parent.get();
        } else {
            break;
        }
    }
    curr_entity
}

fn link_animations(
    player_query: Query<Entity, Added<AnimationPlayer>>,
    parent_query: Query<&Parent>,
    mut links: Query<&mut AnimationLinks>,
) {
    // Get all the Animation players which can be deep and hidden in the heirachy
    for entity in player_query.iter() {
        let top_entity = get_top_parent(entity, &parent_query);

        // If the top parent has an AnimationLinks component then link player to the parent
        if let Ok(mut link_vec) = links.get_mut(top_entity) {
            info!("linking animation to {top_entity:?} for {entity:?}");
            link_vec.push(AnimationEntityLink(entity.clone()));
        }
    }
}

fn animate(
    time: Res<Time>,
    mut links: Query<(&AnimationLinks, &mut MyTimer)>,
    mut players: Query<&mut AnimationPlayer>,
    assets: Res<MyAssets>,
) {
    for (link_vec, mut timer) in links.iter_mut() {
        timer.tick(time.delta());

        if timer.finished() {
            info!("starting  animation");
            for (idx, link) in link_vec.iter().enumerate() {
                if let Ok(mut player) = players.get_mut(link.0) {
                    // Huge assumption here, don't like this
                    if idx == 0 {
                        if player.is_playing_clip(&assets.action_one) {
                            player.replay();
                        } else {
                            player.play(assets.action_one.clone_weak());
                        }
                    } else {
                        if player.is_playing_clip(&assets.action_two) {
                            player.replay();
                        } else {
                            player.play(assets.action_two.clone_weak());
                        }
                    }
                }
            }
        }
    }
}

[rajsahae]

Yes, I was able to do this by retrieving the AnimationClip, querying the Name of the entity, and using that as a conditional. I could probably move this logic to the linking system and store the animation clip handle with the link so that this check is only done once and the player and handle can be kept together.

[rajsahae]

Ok, this worked, I was able to move the AnimationClip/Name check in to the linking system where I also start the player playing, paused, and then in the animation system, I only need to query the player and call player.resume(); player.replay();

Does anyone have suggestions on an alternative?

fn link_animations(
    mut player_query: Query<(Entity, &Name, &mut AnimationPlayer), Added<AnimationPlayer>>,
    parent_query: Query<&Parent>,
    mut animation_links: Query<&mut AnimationLinks>,
    assets: Res<MyAssets>,
    clips: Res<Assets<AnimationClip>>,
) {
    let Some(action_one) = clips.get(&assets.action_one) else {
        return;
    };

    let Some(action_two) = clips.get(&assets.action_two) else {
        return;
    };

    // Get all the Animation players which can be deep and hidden in the heirachy
    for (entity, name, mut player) in player_query.iter_mut() {
        let top_entity = get_top_parent(entity, &parent_query);
        let clip_handle: Handle<AnimationClip> = if action_one.compatible_with(name) {
            assets.action_one.clone_weak()
        } else if action_two.compatible_with(name) {
            assets.action_two.clone_weak()
        } else {
            continue;
        };

        // If the top parent has an autobagger component then link player to the parent
        if let Ok(mut links) = animation_links.get_mut(top_entity) {
            info!("linking animation to {top_entity:?} for {entity:?}");
            links.push(AnimationEntityLink(entity.clone()));
            player.play(clip_handle).pause();
        }
    }
}

fn animate(
    time: Res<Time>,
    mut animation_links: Query<(&AnimationLinks, &mut MyTimer)>,
    mut players: Query<&mut AnimationPlayer>,
) {
    for (links, mut timer) in animation_links.iter_mut() {
        timer.tick(time.delta());

        if timer.finished() {
            info!("starting animation");
            for link in links.iter() {
                if let Ok(mut player) = players.get_mut(link.0) {
                    player.replay();
                    player.resume();
                }
            }
        }
    }
}

I think I'm fairly happy with this