Struct amethyst_assets::AssetLoaderSystemData

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

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,
    options: F::Options,
    progress: P
) -> Handle<A>where
    A: Asset,
    F: Format<A>,
    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>(
    &self,
    name: N,
    format: F,
    options: F::Options,
    source: &S,
    progress: P
) -> Handle<A>where
    A: Asset,
    F: Format<A> + 'static,
    N: Into<String>,
    P: Progress,
    S: AsRef<str> + Eq + Hash + ?Sized,
    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
• options: Additional parameter to format to configure how exactly the data will be created. This could e.g. be mipmap levels for textures.
• 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.

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(res: &mut Resources)

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

fn fetch(res: &'a Resources) -> Self

Fetches the system data from Resources. 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.