Struct bevy::asset::processor::LoadTransformAndSave

pub struct LoadTransformAndSave<L, T, S>
where
    L: AssetLoader,
    T: AssetTransformer<AssetInput = <L as AssetLoader>::Asset>,
    S: AssetSaver<Asset = <T as AssetTransformer>::AssetOutput>,
{ /* private fields */ }

A flexible Process implementation that loads the source Asset using the L AssetLoader, then transforms the L asset into an S AssetSaver asset using the T AssetTransformer, and lastly saves the asset using the S AssetSaver.

When creating custom processors, it is generally recommended to use the LoadTransformAndSave Process implementation, as it encourages you to separate your code into an AssetLoader capable of loading assets without processing enabled, an AssetTransformer capable of converting from an L asset to an S asset, and an AssetSaver that allows you save any S asset. However you can also implement Process directly if LoadTransformAndSave feels limiting or unnecessary.

This uses LoadTransformAndSaveSettings to configure the processor.

Implementations

impl<L, T, S> LoadTransformAndSave<L, T, S>

where L: AssetLoader, T: AssetTransformer<AssetInput = <L as AssetLoader>::Asset>, S: AssetSaver<Asset = <T as AssetTransformer>::AssetOutput>,

pub fn new(transformer: T, saver: S) -> LoadTransformAndSave<L, T, S>

Examples found in repository

examples/asset/processing/asset_processing.rs (line 63)

    fn build(&self, app: &mut App) {
        embedded_asset!(app, "examples/asset/processing/", "e.txt");
        app.init_asset::<CoolText>()
            .init_asset::<Text>()
            .register_asset_loader(CoolTextLoader)
            .register_asset_loader(TextLoader)
            .register_asset_processor::<LoadTransformAndSave<CoolTextLoader, CoolTextTransformer, CoolTextSaver>>(
                LoadTransformAndSave::new(CoolTextTransformer, CoolTextSaver),
            )
            .set_default_asset_processor::<LoadTransformAndSave<CoolTextLoader, CoolTextTransformer, CoolTextSaver>>("cool.ron");
    }

Trait Implementations

impl<Loader, T, Saver> Process for LoadTransformAndSave<Loader, T, Saver>

where Loader: AssetLoader, T: AssetTransformer<AssetInput = <Loader as AssetLoader>::Asset>, Saver: AssetSaver<Asset = <T as AssetTransformer>::AssetOutput>,

type Settings = LoadTransformAndSaveSettings<<Loader as AssetLoader>::Settings, <T as AssetTransformer>::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.

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

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.