Struct bevy_asset::AssetServer
source · pub struct AssetServer { /* private fields */ }
Expand description
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_plugins(AssetPlugin {
watch_for_changes: ChangeWatcher::with_delay(Duration::from_millis(200)),
..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§
source§impl AssetServer
impl AssetServer
sourcepub fn new<T: AssetIo>(source_io: T) -> Self
pub fn new<T: AssetIo>(source_io: T) -> Self
Creates a new asset server with the provided asset I/O.
sourcepub fn with_boxed_io(asset_io: Box<dyn AssetIo>) -> Self
pub fn with_boxed_io(asset_io: Box<dyn AssetIo>) -> Self
Creates a new asset server with a boxed asset I/O.
sourcepub fn preregister_loader(&self, extensions: &[&str])
pub fn preregister_loader(&self, extensions: &[&str])
Pre-register a loader that will later be added.
Assets loaded with matching extensions will be blocked until the real loader is added.
sourcepub fn add_loader<T>(&self, loader: T)where
T: AssetLoader,
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.
sourcepub fn get_handle<T: Asset, I: Into<HandleId>>(&self, id: I) -> Handle<T>
pub fn get_handle<T: Asset, I: Into<HandleId>>(&self, id: I) -> Handle<T>
Gets a strong handle for an asset with the provided id.
sourcepub fn get_handle_untyped<I: Into<HandleId>>(&self, id: I) -> HandleUntyped
pub fn get_handle_untyped<I: Into<HandleId>>(&self, id: I) -> HandleUntyped
Gets an untyped strong handle for an asset with the provided id.
sourcepub fn get_handle_path<H: Into<HandleId>>(
&self,
handle: H
) -> Option<AssetPath<'_>>
pub fn get_handle_path<H: Into<HandleId>>( &self, handle: H ) -> Option<AssetPath<'_>>
Gets the source path of an asset from the provided handle.
sourcepub fn get_load_state<H: Into<HandleId>>(&self, handle: H) -> LoadState
pub fn get_load_state<H: Into<HandleId>>(&self, handle: H) -> LoadState
Gets the load state of an asset from the provided handle.
sourcepub fn get_group_load_state(
&self,
handles: impl IntoIterator<Item = HandleId>
) -> LoadState
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.
sourcepub fn load<'a, T: Asset, P: Into<AssetPath<'a>>>(&self, path: P) -> Handle<T>
pub fn load<'a, T: Asset, P: Into<AssetPath<'a>>>(&self, path: P) -> Handle<T>
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 "BEVY_ASSET_ROOT"
or "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.
sourcepub fn load_untyped<'a, P: Into<AssetPath<'a>>>(&self, path: P) -> HandleUntyped
pub fn load_untyped<'a, P: Into<AssetPath<'a>>>(&self, path: P) -> HandleUntyped
sourcepub fn reload_asset<'a, P: Into<AssetPath<'a>>>(&self, path: P)
pub fn reload_asset<'a, P: Into<AssetPath<'a>>>(&self, path: P)
sourcepub fn load_folder<P: AsRef<Path>>(
&self,
path: P
) -> Result<Vec<HandleUntyped>, AssetServerError>
pub fn load_folder<P: AsRef<Path>>( &self, path: P ) -> Result<Vec<HandleUntyped>, AssetServerError>
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
AssetServerError
s may be returned.
sourcepub fn free_unused_assets(&self)
pub fn free_unused_assets(&self)
Frees unused assets, unloading them from memory.
sourcepub fn mark_unused_assets(&self)
pub fn mark_unused_assets(&self)
Iterates through asset references and marks assets with no active handles as unused.
Trait Implementations§
source§impl Clone for AssetServer
impl Clone for AssetServer
source§fn clone(&self) -> AssetServer
fn clone(&self) -> AssetServer
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moreimpl Resource for AssetServerwhere Self: Send + Sync + 'static,
Auto Trait Implementations§
impl !RefUnwindSafe for AssetServer
impl Send for AssetServer
impl Sync for AssetServer
impl Unpin for AssetServer
impl !UnwindSafe for AssetServer
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.