How Do I Get a Handle to An Asset Created in an Asset Loader?

[zicklag]

I have an issue where I am making a custom asset loader that will depend on a PNG image that it uses to create a TextureAtlass, but I can't get a handle to the TextureAtlas so that I can put it in my custom Asset Struct:

            // Convert that to an asset path for the texture
            let texture_path = AssetPath::new(atlas_file_path.clone(), None);

            // get the texture handle
            let texture_handle: Handle<Texture> = load_context.get_handle(texture_path.clone());

            // Create a new atlas from the texture
            let texture_atlas = TextureAtlas::from_grid(
                texture_handle,
                Vec2::new(grid_size.0 as f32, grid_size.1 as f32),
                tiles.0 as usize,
                tiles.1 as usize,
            );

            // This works,
            // Add it as a labled asset
            load_context.set_labeled_asset::<TextureAtlas>(
                "atlas",
                LoadedAsset::new(texture_atlas).with_dependency(texture_path),
            );

            // But there is no way to get a handle to my TextureAtlass in a custom asset loader?

Adding it as a labeled asset works kind of well, because I can load it like this:

    let character_handle: Handle<Character> = asset_server.load("player1.character.yml");
    let atlas_handle: Handle<TextureAtlas> = asset_server.load("player1.character.yml#atlas");

But it is inconvenient as I would prefer that there be a field already in the Character struct that stores the Handle<TextureAtlas> so that when spawning the character I don't have to manually load two handles and pass those into a bundle.

[inodentry]

You can store the handles in a resource for them to be available for you to use later from any system.

Make a resource type:

struct CharacterAssets {
    texture: Handle<Texture>,
    atlas: Handle<TextureAtlas>,
}

In your setup system (the one you showed, for loading the assets), add a commands: &mut Commands system parameter, and use it to create the resource:

commands.insert_resource(CharacterAssets { texture, atlas });

Then, in the system that spawns your character, you can just get the handles from the resource:

fn my_spawn_system(handles: Res<CharacterAssets>, /* ... */) {
    // use `handles.texture` and `handles.atlas`
}

[zicklag]

I could do that, but that still impacts the user experience because the user still has to load two assets instead of one. I'm trying to make a Bevy plugin and I wanted it to be as easy to use as possible. Still it's not that bad, I just wanted to make sure there wasn't a way to somehow produce that Handle<TextureAtlas> from inside the asset loader's load function.

[inodentry]

Oh, I understand. I've been wondering about similar things, about how the ergonomics of using assets can be improved.

Earlier today I started a discussion about this, first on discord, and now here: #1307 . Hopefully we will have better APIs for asset processing soon!

[mockersf]

You can look at how the gltf loader works.

It loads a struct that contains other handles:

bevy/crates/bevy_gltf/src/lib.rs

Lines 29 to 31 in bff44f7

	pub struct Gltf {
	pub scenes: Vec<Handle<Scene>>,
	pub named_scenes: HashMap<String, Handle<Scene>>,

for examples, for materials, it first loads all the textures with load_context.get_handle, and keeps the handles:

bevy/crates/bevy_gltf/src/loader.rs

Lines 271 to 305 in bff44f7

	fn load_material(material: &Material, load_context: &mut LoadContext) -> Handle<StandardMaterial> {
	let material_label = material_label(&material);
	let pbr = material.pbr_metallic_roughness();
	let mut dependencies = Vec::new();
	let texture_handle = if let Some(info) = pbr.base_color_texture() {
	match info.texture().source().source() {
	gltf::image::Source::View { .. } => {
	let label = texture_label(&info.texture());
	let path = AssetPath::new_ref(load_context.path(), Some(&label));
	Some(load_context.get_handle(path))
	}
	gltf::image::Source::Uri { uri, .. } => {
	let parent = load_context.path().parent().unwrap();
	let image_path = parent.join(uri);
	let asset_path = AssetPath::new(image_path, None);
	let handle = load_context.get_handle(asset_path.clone());
	dependencies.push(asset_path);
	Some(handle)
	}
	}
	} else {
	None
	};
	let color = pbr.base_color_factor();
	load_context.set_labeled_asset(
	&material_label,
	LoadedAsset::new(StandardMaterial {
	albedo: Color::rgba(color[0], color[1], color[2], color[3]),
	albedo_texture: texture_handle,
	..Default::default()
	})
	.with_dependencies(dependencies),
	)
	}

And in the end, all handles are saved in the default object loaded for the asset:

bevy/crates/bevy_gltf/src/loader.rs

Line 253 in bff44f7

load_context.set_default_asset(LoadedAsset::new(Gltf {

[zicklag]

The issue I'm having though is that I need to get a handle to an asset that I created, not one that I can load_context.get_handle. In my use-case, my loader get's a texture handle using load_context.get_handle, but then it creates a TextureAtlas. The issue is getting a handle to the texture atlas I created, which is impossible without having access to an Assets<TextureAtlas> object, which isn't present in the load_context.

The load_context.get_handle strategy works when there is a path to the asset I need a handle to, but when my loader is the source of the asset, there is no path to it. Wait! Unless... Maybe I can use load_context.get_handle("path/to/the/asset/I/am/currently/loading#my-atlas") where my-atlas is the asset that I thought I was unable to get a handle to. 🤔 So the asset get's a handle to itself, essentially, or at least one of it's own named sub-assets. I'll have to try that.

[mockersf]

oh, then on master, set_labeled_asset from the load_context now returns an Handle :)

bevy/crates/bevy_asset/src/loader.rs

Line 92 in 21794fe

pub fn set_labeled_asset<T: Asset>(&mut self, label: &str, asset: LoadedAsset) -> Handle<T> {

[zicklag]

Perfect!

[fantasyRqg]

@zicklag Would you mind provide a sample code ?

[zicklag]

I haven't done this in a while, and I don't have any sample code lying around, unless you can find anything useful in this code here which is different than in the orignal post.

Otherwise see LoadContext::load() which returns a handle.

[nicopap]

Note that this discussion is from January 2021, almost three years ago. Bevy has changed greatly since then. Take anything said in this thread with a grain of salt (actually more than a grain, you should probably ignore it).

As zicklag said, you would want LoadContext::load.

[fantasyRqg]

Thanks a lot. load_context.add_labeled_asset("atlas".to_string(), atlas) solved my problem. At first, I want to add something to asset TextureAtlas and I was not aware of bevy can use type to communicate with engine buffer (Res<Assets<TextureAtlas>>) out of AssetLoader.