How to know when spawn batch Scenes are ready?

[jak6jak]

So I am spawning a lot of models at once using spawn_batch for performance reasons. How do you observe or find out a spawn_batch command completed so that I know when it is good to start playing animations on the created models? Here is my current code:

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);

    // Create a component that stores a reference to our animation.
    commands.insert_resource(Animations {
        graph: graph_handle,
        node_indices: vec![index],
    });

    let spawn_base = commands
        .spawn((Transform::default(), Visibility::default()))
        .id();

    let rat_handle = rat_models.rat.clone();
    commands.spawn_batch((0..10).flat_map(|x| (0..10).map(move |y| (x, y))).map(
        move |(_x, _y)| {
            (
                SceneRoot(rat_handle.clone()),
                Rat,
                Transform::from_xyz((_x as f32 / 10.0), (_y as f32 / 10.0), 0.0)
                    .with_scale(Vec3::splat(1.0)),
                ChildOf(spawn_base),
            )
        },
    ));

Here is my attempt at creating a system that would run supposedly when it is time to play animations:

   fn play_animation_when_ready(
   trigger: Trigger<RatsSpawned>,
   animations: Res<Animations>,
   mut commands: Commands,
   children: Query<&Children>,
   rats: Query<(Entity, &Rat)>,
   mut player: Query<(Entity, &mut AnimationPlayer)>,
) {
  // for (entity, rat) in rats {
       for child in children.iter_descendants() {
           if let Ok((entity, mut player)) = player.get_mut(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;
           }
     //  }
   }
}

[gwafotapa]

From the documentation of SceneRoot: "Once it’s spawned, the entity will have a SceneInstance component."
My attempt would then be to use world::spawn_batch to retrieve the ids of the scene entities and have a system poll every frame until everyone has the component. A SceneInstanceReady trigger is also supposed to be emitted when a scene is ready so you could have an observer count them instead of polling.