bevy_asset_loader 0.27.0

Bevy plugin for asset loading
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use bevy::app::AppExit;
use bevy::asset::AssetPath;
use bevy::platform::collections::HashMap;
use bevy::prelude::*;
use bevy_asset_loader::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .init_state::<MyStates>()
        .add_loading_state(
            LoadingState::new(MyStates::AssetLoading)
                .continue_to_state(MyStates::Next)
                .load_collection::<AudioAssets>(),
        )
        .add_systems(OnEnter(MyStates::Next), use_audio_assets)
        .run();
}

#[derive(AssetCollection, Resource)]
struct AudioAssets {
    // A String as the key will use the full asset path
    #[asset(path = "audio", collection(mapped, typed))]
    full_path: HashMap<String, Handle<AudioSource>>,
    // `FileName` as the key will use the file name (strip away any directories in the path)
    #[asset(path = "audio", collection(mapped, typed))]
    file_name: HashMap<AssetFileName, Handle<AudioSource>>,
    // `FileStem` as the key will use the file name without the extension
    #[asset(path = "audio", collection(mapped, typed))]
    file_stem: HashMap<AssetFileStem, Handle<AudioSource>>,
    // `AssetLabel` as the key uses the label (part after the `#` here)
    // This will panic if an asset in the collection has no label!
    #[asset(
        paths(
            "animated/Fox.glb#Animation0",
            "animated/Fox.glb#Animation1",
            "animated/Fox.glb#Animation2"
        ),
        collection(mapped, typed)
    )]
    fox_animations: HashMap<AssetLabel, Handle<AnimationClip>>,

    // You can implement your own map key types
    #[asset(path = "audio", collection(mapped, typed))]
    custom: HashMap<MyAudio, Handle<AudioSource>>,
}

fn use_audio_assets(audio_assets: Res<AudioAssets>, mut quit: MessageWriter<AppExit>) {
    audio_assets
        .full_path
        .get("audio/plop.ogg")
        .expect("Can access audio asset with full path");
    audio_assets
        .file_name
        .get("plop.ogg")
        .expect("Can access audio asset with file name");
    audio_assets
        .file_stem
        .get("plop")
        .expect("Can access audio asset with file stem");
    audio_assets
        .fox_animations
        .get("Animation0")
        .expect("Can access animation via its label");

    // custom key
    audio_assets
        .custom
        .get(&MyAudio::Plop)
        .expect("Can access audio asset with custom key");

    info!("Everything looks good!");
    info!("Quitting the application...");
    quit.write(AppExit::Success);
}

#[derive(PartialEq, Eq, Hash)]
enum MyAudio {
    Plop,
    Yippee,
    Background,
    Unknown(Box<str>),
}

impl MapKey for MyAudio {
    fn from_asset_path(path: &AssetPath) -> Self {
        let stem = path
            .path()
            .file_stem()
            .unwrap()
            .to_str()
            .expect("Path should be valid UTF-8")
            .to_string();
        match stem.as_str() {
            "plop" => MyAudio::Plop,
            "background" => MyAudio::Background,
            "yippee" => MyAudio::Yippee,
            n => MyAudio::Unknown(n.into()),
        }
    }
}

#[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
enum MyStates {
    #[default]
    AssetLoading,
    Next,
}