Wait for scene spawn to finish before next state

[marko-lazic]

There is a situation where I need to know a final number of entities before doing additional world post-processing.
In the example below, we are loading scene assets from a file. After we load and spawn the scene the game state is being changed. What I expected is that states are hard sync points and that when moving from one to another all threads in the current state finish, before systems start the next state. But this is not the case with this example. I expected that the query counts 3 entities but the query is empty and it seems that scene has not finished spawning yet.

use bevy::prelude::*;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GameState {
    Spawn,
    Count,
}

#[derive(Component, Reflect, Default)]
#[reflect(Component)]
pub struct VortexNode;

fn load_scene(
    mut scene_spawner: ResMut<SceneSpawner>,
    asset_server: Res<AssetServer>,
    mut game_state: ResMut<State<GameState>>,
) {
    let handle: Handle<DynamicScene> = asset_server.load("universe.scn");
    scene_spawner.spawn_dynamic(handle);
    game_state.set(GameState::Count).unwrap();
}

fn count_vortex_nodes(query: Query<Entity, With<VortexNode>>) {
    let nodes_count = query.iter().count();
    info!("Counted {} vortex nodes", nodes_count);
}

fn main() {
    App::new()
        .register_type::<VortexNode>()
        .add_state(GameState::Spawn)
        .add_plugins(DefaultPlugins)
        .add_system_set(SystemSet::on_enter(GameState::Spawn).with_system(load_scene))
        .add_system_set(SystemSet::on_enter(GameState::Count).with_system(count_vortex_nodes))
        .run();
}

Output - expected 3 vortex nodes but it counted 0

2022-02-26T01:09:07.190869Z  INFO scn_and_state: Counted 0 vortex nodes

universe.scn

[
    (
        entity: 0,
        components: [
            {
                "type": "scn_and_state::VortexNode",
                "struct": {},
            },
        ],
    ),
    (
        entity: 1,
        components: [
            {
                "type": "scn_and_state::VortexNode",
                "struct": {},
            },
        ],
    ),
    (
        entity: 2,
        components: [
            {
                "type": "scn_and_state::VortexNode",
                "struct": {},
            },
        ],
    ),
]

I know that everyone pretty much compensates with Added filter but I have to know a finite number of entities before going into the next state. Does anyone have an idea how to solve this? Looking at the bevy_scene it looks very simple. Probably there is some integration lacking between scene and system sets. I want to hear your opinion, ideas on what could be added on a long run, and how to overcome this problem in the short run?

[lukors]

I have never loaded a scene myself, so I'm on pretty thin ice here, but I figured a half-informed answer is better than no answer. :)

I believe asset loading is asynchronous by default, so you probably try to count the vortex nodes before the scene has actually loaded.

I can think of a few possible ways of solving this:

1. Use a function that blocks until it's finished loading, if such a function exists.
2. I believe an event is fired when an asset has loaded, so you could listen for this event in a system in SystemSet::on_update(GameState::Spawn) and change the state when it comes.
3. Maybe you can use the handle to tell if the scene has been loaded?

[marko-lazic]

I tried finding a solution with asset events but I couldn't figure it out. What I came out with is a run criteria, but in the process, I realized that it has an issue so one more workaround was needed to make in order for run criteria to work.

Added two new systems

fn change_state_to_count(mut game_state: ResMut<State<GameState>>) {
    game_state.set(GameState::Count).unwrap();
}

fn scene_loaded(
    game_state: Res<State<GameState>>,
    query: Query<Entity, With<VortexNode>>,
) -> ShouldRun {
    if query.iter().count() > 0 && game_state.current() == &GameState::Spawn {
        ShouldRun::Yes
    } else {
        ShouldRun::No
    }
}

And changed the main to following

fn main() {
    App::new()
        .register_type::<VortexNode>()
        .add_state(GameState::Spawn)
        .add_plugins(DefaultPlugins)
        .add_system_set(SystemSet::on_enter(GameState::Spawn).with_system(load_scene))
        .add_system_set(
            SystemSet::new()
                .with_run_criteria(scene_loaded)
                .with_system(change_state_to_count),
        )
        .add_system_set(SystemSet::on_enter(GameState::Count).with_system(count_vortex_nodes))
        .run();
}

And result

2022-03-01T22:01:23.240795Z  INFO scn_and_state: Counted 3 vortex nodes

✌ 😂

Originally the idea was to have run_criteria within the game state.

fn scene_loaded(query: Query<Entity, With<VortexNode>>) -> ShouldRun {
    if query.iter().count() > 0 {
        ShouldRun::Yes
    } else {
        ShouldRun::No
    }
}
...
.add_system_set(
            SystemSet::on_update(GameState::Spawn)
                .with_run_criteria(scene_loaded)
                .with_system(change_state_to_count),
        )

But there is a well-known issue where the system and run criteria keep running even when the state changes.
Thx to MrGVSV who really solved this last piece of the puzzle, now run criteria loops constantly but the system won't run after game state changes by adding state check in the run criteria.

I think this workaround can be for a while because I don't really have ever to wait for queries other than when loading a fresh scene.