Struct bevy_asset_loader::loading_state::LoadingState

pub struct LoadingState<State: States> { /* private fields */ }

A Bevy plugin to configure automatic asset loading

fn main() {
    App::new()
        .init_state::<GameState>()
        .add_plugins((MinimalPlugins, AssetPlugin::default()))
        .add_loading_state(LoadingState::new(GameState::Loading)
            .continue_to_state(GameState::Menu)
            .load_collection::<AudioAssets>()
            .load_collection::<ImageAssets>()
        )
        .add_systems(OnEnter(GameState::Menu), play_audio)
        .run();
}

fn play_audio(mut commands: Commands, audio_assets: Res<AudioAssets>) {
    commands.spawn(AudioBundle {
        source: audio_assets.background.clone(),
        ..default()
    });
}

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

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

#[derive(AssetCollection, Resource)]
pub struct ImageAssets {
    #[asset(path = "images/player.png")]
    pub player: Handle<Image>,
    #[asset(path = "images/tree.png")]
    pub tree: Handle<Image>,
}

Implementations

impl<S> LoadingState<S>

where S: States,

pub fn new(load: S) -> LoadingState<S>

Create a new LoadingState

This function takes a State during which all asset collections will be loaded and inserted as resources.

    App::new()
        .add_loading_state(
          LoadingState::new(GameState::Loading)
            .continue_to_state(GameState::Menu)
            .load_collection::<AudioAssets>()
            .load_collection::<ImageAssets>()
        )

pub fn continue_to_state(self, next: S) -> Self

The LoadingState will set this Bevy State after all asset collections are loaded and inserted as resources.

    App::new()
        .add_loading_state(
          LoadingState::new(GameState::Loading)
            .continue_to_state(GameState::Menu)
            .load_collection::<AudioAssets>()
            .load_collection::<ImageAssets>()
        )

pub fn on_failure_continue_to_state(self, next: S) -> Self

The LoadingState will set this Bevy State if an asset fails to load.

    App::new()
        .add_loading_state(
          LoadingState::new(GameState::Loading)
            .continue_to_state(GameState::Menu)
            .on_failure_continue_to_state(GameState::Error)
            .load_collection::<MyAssets>()
        )

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

Finish configuring the LoadingState

Calling this function is required to set up the asset loading. Most of the time you do not want to call this method directly though, but complete the setup using LoadingStateAppExt::add_loading_state.

    App::new()
        .add_loading_state(
          LoadingState::new(GameState::Loading)
            .continue_to_state(GameState::Menu)
            .load_collection::<AudioAssets>()
            .load_collection::<ImageAssets>()
        )

Trait Implementations

impl<S: States> ConfigureLoadingState for LoadingState<S>

fn load_collection<A: AssetCollection>(self) -> Self

Add the given collection to the loading state.

fn init_resource<R: Resource + FromWorld>(self) -> Self

The resource will be initialized at the end of the loading state using its FromWorld implementation. All asset collections will be available at that point and fully loaded.

fn register_dynamic_asset_collection<C: DynamicAssetCollection + Asset>( self ) -> Self

Register a custom dynamic asset collection type

fn with_dynamic_assets_file<C: DynamicAssetCollection + Asset>( self, file: &str ) -> Self

Add a file containing dynamic assets to the loading state. Keys contained in the file, will be available for asset collections.