How to play animations on many entities?

[jak6jak]

I'm struggling to understand how to play animations for a bunch of entities. This code originally worked with one entity but I am struggling to understand how to expand on that for many entities. I'm trying to use the stress test "many foxes" as an example but I'm confused on how to get it working for myself. Here is my code:

use bevy::{
    prelude::*
};
use bevy_asset_loader::prelude::*;
use bevy_panorbit_camera::{PanOrbitCamera, PanOrbitCameraPlugin};


// Not sure how this is supposed to work
#[derive(Resource)]
struct Animations {
    graph: Handle<AnimationGraph>,
    node_indices: Vec<AnimationNodeIndex>,
}

fn main() {
    App::new()
        .add_plugins((DefaultPlugins,PanOrbitCameraPlugin))

        .init_state::<MyStates>()
        .add_loading_state(
            LoadingState::new(MyStates::AssetLoading)
                .continue_to_state(MyStates::Next)
                .load_collection::<RatModels>()
                .load_collection::<WorldMaterial>(),
        )
        .add_systems(OnEnter(MyStates::Next),(show_model, play_animation_when_ready).chain())
        .run();
}

fn show_model(mut commands: Commands, rat_models: Res<RatModels>, mut graphs: ResMut<Assets<AnimationGraph>>, env : Res<WorldMaterial>){
    // Spawn the scene directly using the loaded handle


    // Also spawn a camera to view the model
    commands.spawn((
        Transform::from_translation(Vec3::new(0.0, 1.5, 5.0)),
        PanOrbitCamera::default(),
        EnvironmentMapLight {
            diffuse_map: env.diffuse_map.clone(),
            specular_map: env.specular_map.clone(),
            intensity: 900.0,
            ..default()
        }
    ));

    // Add a light to illuminate the scene
    commands.spawn((
        DirectionalLight::default(),
        Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, -0.5, -0.5, 0.0)),
    ));

    let(graph,index) = AnimationGraph::from_clip(rat_models.animation_clip.clone());
    let graph_handle = graphs.add(graph);

    commands.insert_resource(Animations {
        graph: graph_handle,
        node_indices: vec![index],
    });

    let spawn_base = commands.spawn((Transform::default(), Visibility::default())).id();
    for rat_x in 0..10 {
        for rat_y in 0..10 {
            commands.entity(spawn_base).with_children(|builder| {
                builder.spawn((
                    SceneRoot(rat_models.rat.clone()),
                    Transform::from_xyz((rat_x as f32 / 10.0), (rat_y as f32 / 10.0), 0.0)
                        .with_scale(Vec3::splat(1.0)),

                    ));
            });
        }
    }
}
// Does this need to be a separate system?
fn play_animation_when_ready(
    animations: Res<Animations>,
    mut commands: Commands,
    children: Query<&Children>,
    mut player: Query<(Entity, &mut AnimationPlayer)>,
    mut done: Local<bool>
){

    if !*done && player.iter().len() == 100 {
        for (entity, mut player) in &mut player {
            commands
                .entity(entity)
                .insert(AnimationGraphHandle(animations.graph.clone()))
                .insert(AnimationTransitions::new());

            let playing_animation = player.play(animations.node_indices[0]).repeat();

        }
        *done = true;
    }



}

#[derive(AssetCollection,Resource)]
struct RatModels {
    #[asset(path = "blackrat_free_glb\\blackrat.glb#Scene0")]
    rat: Handle<Scene>,
    #[asset(path = "blackrat_free_glb\\blackrat.glb#Animation1")]
    animation_clip: Handle<AnimationClip>,

}
#[derive(AssetCollection,Resource)]
struct WorldMaterial {
    #[asset(path = "EnviromentMaps\\pisa_diffuse_rgb9e5_zstd.ktx2")]
    diffuse_map: Handle<Image>,
    #[asset(path = "EnviromentMaps\\pisa_specular_rgb9e5_zstd.ktx2")]
    specular_map: Handle<Image>,
}
#[derive(Clone,Eq,PartialEq, Debug,Hash,Default,States)]
enum MyStates {
    #[default]
    AssetLoading,
    Next,
}

I think some of my core misunderstandings is the animationGraph especially since I currently have a single animation I want to play for all rats.

[hukasu]

play should be called through AnimationTransitions

     for (entity, mut player) in &mut player {
         let mut animation_transitions = AnimationTransitions::new();
         let playing_animation = animation_transitions.play(&mut player, animations.node_indices[0]).repeat();
         commands
                .entity(entity)
                .insert(AnimationGraphHandle(animations.graph.clone()))
                .insert(animation_transitions);
        }

or something like this

Models take some time to spawn

you do have play_animation_when_ready after show_models, but on the frame that commands.spawn is called, you only have the entity with SceneRoot but not the children from the scene, so you need to actually wait for more frames before running player_animation_when_ready, one way is with an observer with Trigger<SceneInstanceReady>

[hukasu]

you now have 100 entities with AnimationPlayer, so single_mut returns an error saying there are more than one entity

[hukasu]

for your case you should do children.iter_descendants(trigger.target()) and then find the child entity with the AnimationPlayer

[jak6jak]

How should I be getting the animationPlayers then?

[hukasu]

fn play_animation_when_ready(
    trigger: Trigger<SceneInstanceReady>,
    animations: Res<Animations>,
    mut commands: Commands,
    children: Query<&Children>,
    mut player: Query<(Entity, &mut AnimationPlayer)>,
) {
    for child in children.iter_descendants(trigger.target()) {
       if let Ok((entity, mut player)) = player.get(child) {
        let mut animation_transitions = AnimationTransitions::new();
        let playing_animation = animation_transitions
            .play(
                &mut player,
                animations.node_indices[0],
                Duration::from_millis(15),
            )
            .repeat();
        commands
            .entity(entity)
            .insert(AnimationGraphHandle(animations.graph.clone()))
            .insert(animation_transitions);
        break;
    }
    }
}