Struct bevy_asset_loader::AssetLoader

pub struct AssetLoader<T> { /* fields omitted */ }

A Bevy plugin to configure automatic asset loading

fn main() {
let mut app = App::build();
    AssetLoader::new(GameState::Loading, GameState::Menu)
        .with_collection::<AudioAssets>()
        .with_collection::<TextureAssets>()
        .build(&mut app);

    app.add_state(GameState::Loading)
        .add_plugins(MinimalPlugins)
        .add_plugin(AssetPlugin::default())
        .add_system_set(SystemSet::on_enter(GameState::Menu)
            .with_system(play_audio.system())
        )
        .run();
}

fn play_audio(audio_assets: Res<AudioAssets>, audio: Res<Audio>) {
    audio.play(audio_assets.flying.clone());
}

#[derive(Clone, Eq, PartialEq, Debug, Hash)]
enum GameState {
    Loading,
    Menu
}

#[derive(AssetCollection)]
pub struct AudioAssets {
    #[asset(path = "audio/background.ogg")]
    pub background: Handle<AudioSource>,
}

#[derive(AssetCollection)]
pub struct TextureAssets {
    #[asset(path = "textures/player.png")]
    pub player: Handle<Texture>,
    #[asset(path = "textures/tree.png")]
    pub tree: Handle<Texture>,
}

Implementations

impl<T> AssetLoader<T> where
    T: Component + Debug + Clone + Eq + Hash, 

pub fn new(load: T, next: T) -> AssetLoader<T>

Create a new AssetLoader

This function takes two States. During the first all assets will be loaded and the collections will be inserted as resources. Then the second state is set in your Bevy App.

    let mut app = App::build();
    AssetLoader::new(GameState::Loading, GameState::Menu)
        .with_collection::<AudioAssets>()
        .with_collection::<TextureAssets>()
        .build(&mut app);

pub fn with_collection<A: AssetCollection>(self) -> Self

Add an AssetCollection to the AssetLoader

The added collection will be loaded and inserted into your Bevy App as a resource.

    let mut app = App::build();
    AssetLoader::new(GameState::Loading, GameState::Menu)
        .with_collection::<AudioAssets>()
        .with_collection::<TextureAssets>()
        .build(&mut app);

pub fn build(self, app: &mut AppBuilder)

Finish configuring the AssetLoader

Calling this function is required to set up the asset loading.

    let mut app = App::build();
    AssetLoader::new(GameState::Loading, GameState::Menu)
        .with_collection::<AudioAssets>()
        .with_collection::<TextureAssets>()
        .build(&mut app);