Struct bevy_internal::asset::processor::LoadAndSave

pub struct LoadAndSave<L, S>
where
    L: AssetLoader,
    S: AssetSaver<Asset = <L as AssetLoader>::Asset>,
{ /* private fields */ }

A flexible Process implementation that loads the source Asset using the L AssetLoader, then saves that L asset using the S AssetSaver.

This is a specialized use case of LoadTransformAndSave and is useful where there is no asset manipulation such as when compressing assets.

This uses LoadAndSaveSettings to configure the processor.

Trait Implementations

impl<L, S> From<S> for LoadAndSave<L, S>

where L: AssetLoader, S: AssetSaver<Asset = <L as AssetLoader>::Asset>,

fn from(value: S) -> LoadAndSave<L, S>

Converts to this type from the input type.

impl<Loader, Saver> Process for LoadAndSave<Loader, Saver>

where Loader: AssetLoader, Saver: AssetSaver<Asset = <Loader as AssetLoader>::Asset>,

type Settings = LoadAndSaveSettings<<Loader as AssetLoader>::Settings, <Saver as AssetSaver>::Settings>

The configuration / settings used to process the asset. This will be stored in the AssetMeta and is user-configurable per-asset.

type OutputLoader = <Saver as AssetSaver>::OutputLoader

The AssetLoader that will be used to load the final processed asset.

fn process<'a>( &'a self, context: &'a mut ProcessContext<'_>, meta: AssetMeta<(), LoadAndSave<Loader, Saver>>, writer: &'a mut (dyn AsyncWrite + Send + Sync + Unpin + 'static) ) -> Pin<Box<dyn Future<Output = Result<<<LoadAndSave<Loader, Saver> as Process>::OutputLoader as AssetLoader>::Settings, ProcessError>> + Send + 'a>>

Processes the asset stored on context in some way using the settings stored on meta. The results are written to writer. The final written processed asset is loadable using Process::OutputLoader. This load will use the returned AssetLoader::Settings.