Reuse the same scene from gltf file brakes scene animation

[volodalexey]

Bevy version

0.10.1

What you did

For example you can use the official animated_fox example. After spawning the first fox, try to spawn the second fox at line 74:

// Fox
commands.spawn(SceneBundle {
    scene: asset_server.load("models/animated/Fox.glb#Scene0"),
    ..default()
});

commands.spawn(SceneBundle {
    transform: Transform::from_xyz(50.0, 0.0, 0.0),
    scene: asset_server.load("models/animated/Fox.glb#Scene0"),
    ..default()
});

As a result animation for the first fox and second will be broken.
Instance of player if let Ok(mut player) = player.get_single_mut() - will never be acquired.

What went wrong

When I copy the same scene at least second time - animation will be broken.

I want to load gltf/glb file and spawn multiple instances of the same mesh/scene with its own animation.
E.g. gltf file contains ball-mesh + ball-animation, animation is simple just to rotate the ball around its origin.
Next I want to spawn these balls by timer. Each ball should also use the same animation and mesh/scene.
I want to prepare animations and scenes in Blender.

Some thoughts

It is unclear, how instanse of AnimationPlayer is added. My main target would be WASM - so I want to decrease network requests - and I want to have one gltf file with multiple scenes - e.g. scene-player-ball-and-animation + scene-enemy-ball-and-animation, etc.

• Why SceneBundle do not spawn animation atomatically from file?
• Is it possible to spawn AnimationPlayer manually, e.g. combine SceneBundle from gltf file manually ?

Might be connected with:
#5848
#1802

[nicopap]

So I closed the issue, because this is more a question on how to do something than reporting a bug.

I invite you to open a new issue if you think the example is misleading (I would agree on this).

---

So there is a slight misunderstanding here.

I think you are referencing to the following code right?

bevy/examples/animation/animated_fox.rs

Lines 83 to 95 in d90c65d

	// Once the scene is loaded, start the animation
	fn setup_scene_once_loaded(
	animations: Res<Animations>,
	mut player: Query<&mut AnimationPlayer>,
	mut done: Local<bool>,
	) {
	if !*done {
	if let Ok(mut player) = player.get_single_mut() {
	player.play(animations.0[0].clone_weak()).repeat();
	*done = true;
	}
	}
	}

analysis of setup_scene_once_loaded

Let me go through the function here:

• This system runs until done is set to true
• When it detects that a AnimationPlayer is created, it will play the first animation (not spawn it, just enable it) and set done to true.

So the system is very specific to spawning a single entity and animating it, it makes the following assumptions:

• There will be exactly one AnimationPlayer spawned for the entirety of the game's lifetime.
• The AnimationPlayer has at least 1 animation
• We want to start the first animation as soon as the entity is spawned.

In most games, those assumptions do not hold!

In fact, there is a different bevy example with several foxes many foxes

How bevy spawns animation

So where are the animations coming from? It's not setup_scene_once_loaded that spawns it, it only enables an existing one.

Let's look at the glTF loader:

bevy/crates/bevy_gltf/src/loader.rs

Lines 479 to 490 in d90c65d

	#[cfg(feature = "bevy_animation")]
	{
	// for each node root in a scene, check if it's the root of an animation
	// if it is, add the AnimationPlayer component
	for node in scene.nodes() {
	if animation_roots.contains(&node.index()) {
	world
	.entity_mut(*node_index_to_entity_map.get(&node.index()).unwrap())
	.insert(bevy_animation::AnimationPlayer::default());
	}
	}
	}

Turns out AnimationPlayer is created by the loader itself! This means that the Scene you get from Assets<Scene>::get(Handle<Scene>) already holds the AnimationPlayer component. And every time you spawn that scene, it will be copied as a new component.

Controlling animations programatically

So how would I control AnimationClip from several scenes?

Let's see the many_foxes example's way:

bevy/examples/stress_tests/many_foxes.rs

Lines 200 to 212 in d90c65d

	fn setup_scene_once_loaded(
	animations: Res<Animations>,
	foxes: Res<Foxes>,
	mut player: Query<&mut AnimationPlayer>,
	mut done: Local<bool>,
	) {
	if !*done && player.iter().len() == foxes.count {
	for mut player in &mut player {
	player.play(animations.0[0].clone_weak()).repeat();
	}
	*done = true;
	}
	}

This supports animating literally a thousand foxes! But it stays difficult to update after the fact the animation.

How you would do it depends on what you intend to do with the animations? Are the different scenes to be animated independently, or in sync?

You could use https://github.com/nicopap/bevy-scene-hook and then add a component to the entity with the AnimationPlayer like so:

#[derive(Component)]
struct AnimateThis(i32);

cmds.spawn_bundle(HookedSceneBundle {
    scene: SceneBundle { scene: asset_server.load("scene.glb#Scene0"), ..default() },
    hook: SceneHook::new(|entity, cmds| {
        if entity.contains::<AnimationPlayer>() {
            cmds.insert(AnimateThis(3));
        }
    }),
});

Then, within a system, you could query for AnimateThis and animate specific scenes:

struct AnimateIndex { index: i32 }

fn animate_sys(
    animations: Res<Animations>,
    mut query: Query<(&mut AnimationPlayer, &AnimateThis)>,
    mut events: EventReader<AnimateIndex>,
) {
    for to_animate in events.iter() {
        let (mut to_animate, _) = query.iter_mut().find(|(_, n)| n.0  == to_animate.index).unwrap();
        to_animate.play(animations.0[0].clone_weak());
    }
}

[volodalexey]

@nicopap Thanks!

Ok. Now I see the problem.

So, for each scene from gltf file loader creates its own AnimationPlayer.
That is why this line will not work for 2+ foxes:

if let Ok(mut player) = player.get_single_mut() {
  // unreachable for 2+ foxes created as gltf scene
  player.play(animations.0[0].clone_weak()).repeat();
  *done = true;
}

As a solution when I add more than one fox scene:

let fox_handle = asset_server.load("models/animated/Fox.glb#Scene0");
// Fox
commands.spawn(SceneBundle {
    scene: fox_handle.clone(),
    ..default()
});

commands.spawn(SceneBundle {
    transform: Transform::from_xyz(50.0, 0.0, 0.0),
    scene: fox_handle.clone(),
    ..default()
});

I need to iterate throuhg all players:

if !*done {
    for mut player in &mut player {
        player.play(animations.0[0].clone_weak()).repeat();
        *done = true;
    }
}

And the second part of my question is how to track all those players - it is also answered. Just to keep track of spawned scenes count and play them when ready.

[nicopap]

Yes.

Optionally, I think it's possible to replace the query:

-    mut player: Query<&mut AnimationPlayer>, 
+    mut player: Query<&mut AnimationPlayer, Added<AnimationPlayer>>, 

This way when you iterate over the players, you only iterate over the newly added players.