Query for unloaded assets

[torsteingrindvik]

In a big Bevy app, I'd like to globally check if anything is in the process of being loaded.

My first attempt is this:

fn is_all_done_loading(mut done: Local<bool>, query: Query<&LoadState>) {
    if *done {
        return;
    };

    let total = query.iter().count();
    let ready = query
        .iter()
        .filter(|state| matches!(state, &&LoadState::Loaded))
        .count();

    info!("Load state: {ready}/{total}");

    if total == ready && total > 0 {
        *done = true;
    }
}

But it reports 0 total even though things are loading.

I would like this to be non-intrusive if possible so I can avoid having a global untyped handle collection because I have many different plugins and many different asset types.

Is there a way?

[torsteingrindvik]

I found a way that works and isn't too bad:

#[derive(Debug, Resource)]
pub struct TrackingAssetServer {
    pub server: AssetServer,
    pub added: Vec<UntypedHandle>,
}

impl TrackingAssetServer {
    /// Wraps the normal [`AssetServer`] call, tracking an untyped version of it such that we may later query
    /// if all assets are loaded.
    #[must_use = "not using the returned strong handle may result in the unexpected release of the asset"]
    pub fn load<'a, A: Asset>(&mut self, path: impl Into<AssetPath<'a>>) -> Handle<A> {
        let handle = self.server.load(path);

        self.added.push(handle.clone_weak().untyped());

        handle
    }
}

Then I just replaced all my uses of asset_server with this wrapper.
I then have a system which runs http://dev-docs.bevyengine.org/bevy/asset/struct.AssetServer.html#method.is_loaded_with_dependencies on the handles.

[nicopap]

Nice you could find a solution by yourself, but question: Would this query filter have helped you #5080 ?

[torsteingrindvik]

Hm, I looked at the PR now, and I don't think so?

I needed a way to inspect all assets, but your PR seems to relate to generics via A: Asset.
I need something type erased.

[nicopap]

Ah, I see. My bad. On a second read, this seems to be indeed something completely different.

Your solution is perfectly fine, I wouldn't have done it differently.

[torsteingrindvik]

I think I have seen your name on asset related PRs so I'm wondering if you have any thoughts on if something like this should be available in Bevy itself?

I don't mean this particular impl necessarily but a way to get hold of all handles.

[nicopap]

Yeah I see the interest in being able to iterate over all asset handles independently of the asset type.

I did take a look now, and I think it's not too hard to implement:

1. There is ReflectAsset::ids already. You can get the list of UntypedAssetId from an asset that implements Reflect with this.
2. To get a ReflectAsset, you need to call TypeRegistration::data::<ReflectAsset>().
3. You usually get a TypeRegistration from TypeRegistry::get, but here it's not what you want, you want to get the ids for all known assets. Therefore, you'd need to iterate all registrations with TypeRegistry::iter.

The drawback is that the asset needs to be added using register_asset_reflect, I'm not sure if all the bevy assets are registered this way.