Struct bevy::asset::Assets

pub struct Assets<T> where
    T: Asset,  { /* private fields */ }

Stores Assets of a given type and tracks changes to them.

Each asset is mapped by a unique HandleId, allowing any Handle with the same HandleId to access it. These assets remain loaded for as long as a Strong handle to that asset exists.

To store a reference to an asset without forcing it to stay loaded, you can use a Weak handle. To make a Weak handle a Strong one, use Assets::get_handle or pass the Assets collection into the handle’s make_strong method.

Remember, if there are no Strong handles for an asset (i.e. they have all been dropped), the asset will unload. Make sure you always have a Strong handle when you want to keep an asset loaded!

Implementations

impl<T> Assets<T> where
    T: Asset, 

pub fn add(&mut self, asset: T) -> Handle<T>

Adds an asset to the collection, returning a Strong handle to that asset.

Events

• AssetEvent::Created

pub fn set<H>(&mut self, handle: H, asset: T) -> Handle<T> where
    H: Into<HandleId>, 

Add/modify the asset pointed to by the given handle.

Unless there exists another Strong handle for this asset, it’s advised to use the returned Strong handle. Not doing so may result in the unexpected release of the asset.

See set_untracked for more info.

pub fn set_untracked<H>(&mut self, handle: H, asset: T) where
    H: Into<HandleId>, 

Add/modify the asset pointed to by the given handle.

If an asset already exists with the given HandleId, it will be modified. Otherwise the new asset will be inserted.

Events

• AssetEvent::Created: Sent if the asset did not yet exist with the given handle
• AssetEvent::Modified: Sent if the asset with given handle already existed

pub fn get<H>(&self, handle: H) -> Option<&T> where
    H: Into<HandleId>, 

Get the asset for the given handle.

This is the main method for accessing asset data from an Assets collection. If you need mutable access to the asset, use get_mut.

pub fn contains<H>(&self, handle: H) -> bool where
    H: Into<HandleId>, 

Checks if an asset exists for the given handle

pub fn get_mut<H>(&mut self, handle: H) -> Option<&mut T> where
    H: Into<HandleId>, 

Get mutable access to the asset for the given handle.

This is the main method for mutably accessing asset data from an Assets collection. If you do not need mutable access to the asset, you may also use get.

pub fn get_handle<H>(&self, handle: H) -> Handle<T> where
    H: Into<HandleId>, 

Gets a Strong handle pointing to the same asset as the given one

pub fn get_or_insert_with<H>(
    &mut self,
    handle: H,
    insert_fn: impl FnOnce() -> T
) -> &mut T where
    H: Into<HandleId>, 

Get mutable access to an asset for the given handle, inserting a new value if none exists.

Events

• AssetEvent::Created: Sent if the asset did not yet exist with the given handle

pub fn iter(&self) -> impl Iterator<Item = (HandleId, &T)>

Get an iterator over all assets in the collection.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (HandleId, &mut T)>

Get a mutable iterator over all assets in the collection.

pub fn ids(&self) -> impl Iterator<Item = HandleId>

Get an iterator over all HandleId’s in the collection.

pub fn remove<H>(&mut self, handle: H) -> Option<T> where
    H: Into<HandleId>, 

Remove an asset for the given handle.

The asset is returned if it existed in the collection, otherwise None.

Events

• AssetEvent::Removed

pub fn clear(&mut self)

Clears the inner asset map, removing all key-value pairs.

Keeps the allocated memory for reuse.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted into the assets.

The collection may reserve more space to avoid frequent reallocations.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the asset map as much as possible.

It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.

pub fn asset_event_system(
    events: EventWriter<'_, '_, AssetEvent<T>>,
    assets: ResMut<'_, Assets<T>>
)

pub fn len(&self) -> usize

Gets the number of assets in the collection

pub fn is_empty(&self) -> bool

Returns true if there are no stored assets

Trait Implementations

impl<T> Debug for Assets<T> where
    T: Debug + Asset, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.