GLTF loader uses indices instead of names to reference AnimationClips

[adamwych]

Hello. Does anyone know why GLTF loader uses indices instead of names to reference animations?
Relevant code (https://github.com/bevyengine/bevy/blob/main/crates/bevy_gltf/src/loader.rs#LL205C28-L205C28):

let handle = load_context.set_labeled_asset(
    &format!("Animation{}", animation.index()),
    LoadedAsset::new(animation_clip),
);

Because of this, to get a handle to an AnimationClip you have to do something like this:

assets.load("model.glb#Animation0")

I could not find any discussion regarding this or any comment explaining why it was implemented this way.
This does not seem very friendly for developers, since there's no way to know which animation occupies which index without going through each one and checking manually or using a separate system to figure that out.

[mockersf]

Animation names are optional, so we don't have a guarantee that there is one. It's also not possible in the current asset system to have two labels for the same asset. So in a case where multiple animations but some without names, there would be a mixed of names and index with holes... Exposing the indexes is the only way for now to have something consistent...

Also, if you load the whole gltf, you will have access to animations by name

[adamwych]

Thanks, I understand the issue, but doesn't it seem reasonable that in reality most people will have to give a unique name to each animation (except in cases when they only have 1 animation)?

My use case is that I created a simple state machine utility that manages animations and I have a function that spawns an entity:

fn spawn_test_character(assets: &AssetServer) -> impl Bundle {
    (
        SceneBundle {
            scene: assets.load("character.glb#Scene0"),
            ..default()
        },
        AnimationController {
            state_machine: StateMachineBuilder::new()
                .with_states(vec![
                    StateMachineState {
                        clip: assets.load("character.glb#Animation0"),
                        condition: /* ... */,
                    },
                ]).build()
            // ...
        }
    )
}

As you can see, each StateMachineState specifies which clip should be played when the machine goes into that state. As I understand assets are loaded asynchronously, so I can not access Gltf here, yet, so I am not able to figure out which animation is on which index at this point. Seems like there are only 2 possibilities here:

• Preload assets before that function is called and use Res<Assets<Gltf>> instead of AssetServer.
• Change clip to a String instead of Handle<AnimationClip> and use a dedicated system to find corresponding AnimationClip after the file is loaded.

Both of those options seem to be unnecessarily complicating the entire thing considering that the loader will load names of all animations that have names, just won't allow me to access them using the name#label notation...

[mrchantey]

I ended up writing a little deno script to find the indices:

const animations = ["Foo","Bar"]
let buff = await Deno.readFile('my-file.gltf')
let txt = new TextDecoder().decode(buff)
let gltf = JSON.parse(txt)
const indices = animations.reduce((acc, name) => {
  acc[name] = gltf.animations.findIndex(anim => anim.name === name)
  return acc
}, {})
console.dir(indices)