Struct bevy::asset::AssetServer

pub struct AssetServer { /* private fields */ }

Loads assets from the filesystem in the background.

The asset server is the primary way of loading assets in bevy. It keeps track of the load state of the assets it manages and can even reload them from the filesystem with

// The asset plugin can be configured to watch for asset changes.
app.add_plugin(AssetPlugin {
    watch_for_changes: true,
    ..Default::default()
});

The asset server is a resource, so in order to access it in a system you need a Res accessor, like this:

use bevy_asset::{AssetServer, Handle};
use bevy_ecs::prelude::{Commands, Res};


fn my_system(mut commands: Commands, asset_server: Res<AssetServer>)
{
    // Now you can do whatever you want with the asset server, such as loading an asset:
    let asset_handle: Handle<Image> = asset_server.load("cool_picture.png");
}

See the asset_loading example for more information.

Implementations

impl AssetServer

pub fn new<T>(source_io: T) -> AssetServerwhere
    T: AssetIo,

Creates a new asset server with the provided asset I/O.

pub fn with_boxed_io(
    asset_io: Box<dyn AssetIo + 'static, Global>
) -> AssetServer

Creates a new asset server with a boxed asset I/O.

pub fn asset_io(&self) -> &(dyn AssetIo + 'static)

Returns the associated asset I/O.

pub fn add_loader<T>(&self, loader: T)where
    T: AssetLoader,

Adds the provided asset loader to the server.

If loader has one or more supported extensions in conflict with loaders that came before it, it will replace them.

pub fn get_handle<T, I>(&self, id: I) -> Handle<T>where
    T: Asset,
    I: Into<HandleId>,

Gets a strong handle for an asset with the provided id.

pub fn get_handle_untyped<I>(&self, id: I) -> HandleUntypedwhere
    I: Into<HandleId>,

Gets an untyped strong handle for an asset with the provided id.

pub fn get_handle_path<H>(&self, handle: H) -> Option<AssetPath<'_>>where
    H: Into<HandleId>,

Gets the source path of an asset from the provided handle.

pub fn get_load_state<H>(&self, handle: H) -> LoadStatewhere
    H: Into<HandleId>,

Gets the load state of an asset from the provided handle.

pub fn get_group_load_state(
    &self,
    handles: impl IntoIterator<Item = HandleId>
) -> LoadState

Gets the overall load state of a group of assets from the provided handles.

This method will only return LoadState::Loaded if all assets in the group were loaded successfully.

pub fn load<'a, T, P>(&self, path: P) -> Handle<T>where
    T: Asset,
    P: Into<AssetPath<'a>>,

Queues an Asset at the provided relative path for asynchronous loading.

The absolute path to the asset is "ROOT/ASSET_FOLDER_NAME/path". Its extension is then extracted to search for an asset loader. If an asset path contains multiple dots (e.g. foo.bar.baz), each level is considered a separate extension and the asset server will try to look for loaders of bar.baz and baz assets.

By default the ROOT is the directory of the Application, but this can be overridden by setting the "CARGO_MANIFEST_DIR" environment variable (see https://doc.rust-lang.org/cargo/reference/environment-variables.html) to another directory. When the application is run through Cargo, then "CARGO_MANIFEST_DIR" is automatically set to the root folder of your crate (workspace).

The name of the asset folder is set inside the AssetPlugin. The default name is "assets".

The asset is loaded asynchronously, and will generally not be available by the time this calls returns. Use AssetServer::get_load_state to determine when the asset is effectively loaded and available in the Assets collection. The asset will always fail to load if the provided path doesn’t contain an extension.

pub fn load_untyped<'a, P>(&self, path: P) -> HandleUntypedwhere
    P: Into<AssetPath<'a>>,

Queues the Asset at the provided path for loading and returns an untyped handle.

See load.

pub fn reload_asset<'a, P>(&self, path: P)where
    P: Into<AssetPath<'a>>,

Force an Asset to be reloaded.

This is useful for custom hot-reloading or for supporting watch_for_changes in custom AssetIo implementations.

pub fn load_folder<P>(
    &self,
    path: P
) -> Result<Vec<HandleUntyped, Global>, AssetServerError>where
    P: AsRef<Path>,

Loads assets from the specified folder recursively.

Errors

• If the provided path is not a directory, it will fail with AssetServerError::AssetFolderNotADirectory.
• If something unexpected happened while loading an asset, other AssetServerErrors may be returned.

pub fn free_unused_assets(&self)

Frees unused assets, unloading them from memory.

pub fn mark_unused_assets(&self)

Iterates through asset references and marks assets with no active handles as unused.

Trait Implementations

impl Clone for AssetServer

fn clone(&self) -> AssetServer

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Resource for AssetServerwhere
    AssetServer: 'static + Send + Sync,