Struct amethyst_assets::AssetLoaderSystemData

pub struct AssetLoaderSystemData<'a, A> where
    A: Asset,  { /* fields omitted */ }

Helper type for loading assets

Implementations

impl<'a, A> AssetLoaderSystemData<'a, A> where
    A: Asset, 

pub fn load<F, N, P>(&self, name: N, format: F, progress: P) -> Handle<A> where
    F: Format<A::Data>,
    N: Into<String>,
    P: Progress, 

Loads an asset with a given format from the default (directory) source. If you want to load from a custom source instead, use load_from.

See load_from for more information.

pub fn load_from<F, N, P, S: ?Sized>(
    &self,
    name: N,
    format: F,
    source: &S,
    progress: P
) -> Handle<A> where
    F: Format<A::Data>,
    N: Into<String>,
    P: Progress,
    S: AsRef<str> + Eq + Hash,
    String: Borrow<S>, 

Loads an asset with a given id and format from a custom source. The actual work is done in a worker thread, thus this method immediately returns a handle.

Parameters

• name: this is just an identifier for the asset, most likely a file name e.g. "meshes/a.obj"
• format: A format struct which loads bytes from a source and produces Asset::Data with them
• source: An identifier for a source which has previously been added using with_source
• progress: A tracker which will be notified of assets which have been imported

pub fn load_from_data<P>(&self, data: A::Data, progress: P) -> Handle<A> where
    A: Asset,
    P: Progress, 

Load an asset from data and return a handle.

pub fn load_from_data_async<P, F>(&self, data: F, progress: P) -> Handle<A> where
    A: Asset,
    P: Progress,
    F: FnOnce() -> A::Data + Send + Sync + 'static, 

Asynchronously load an asset from data and return a handle.

Trait Implementations

impl<'a, A> SystemData<'a> for AssetLoaderSystemData<'a, A> where
    A: Asset,
    ReadExpect<'a, Loader>: SystemData<'a>,
    Read<'a, AssetStorage<A>>: SystemData<'a>, 

fn setup(world: &mut World)

Sets up the system data for fetching it from the World.

fn fetch(world: &'a World) -> Self

Fetches the system data from World. Note that this is only specified for one concrete lifetime 'a, you need to implement the SystemData trait for every possible lifetime.

fn reads() -> Vec<ResourceId>

Returns all read dependencies as fetched from Self::fetch.

fn writes() -> Vec<ResourceId>

Returns all write dependencies as fetched from Self::fetch.