Struct 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.

If your Process does not need to transform the Asset, you can use IdentityAssetTransformer as T. This will directly return the input Asset, allowing your Process to directly load and then save an Asset. However, this pattern should only be used for cases such as file format conversion. Otherwise, consider refactoring your AssetLoader and AssetSaver to isolate the transformation step into an explicit AssetTransformer.

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<L, S> From<S> for LoadTransformAndSave<L, IdentityAssetTransformer<<L as AssetLoader>::Asset>, S>

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

fn from( value: S, ) -> LoadTransformAndSave<L, IdentityAssetTransformer<<L as AssetLoader>::Asset>, S>

Converts to this type from the input type.

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

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

type Settings = LoadTransformAndSaveSettings<<Loader as AssetLoader>::Settings, <Transformer 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( &self, context: &mut ProcessContext<'_>, meta: AssetMeta<(), LoadTransformAndSave<Loader, Transformer, Saver>>, writer: &mut (dyn AsyncWrite + Send + Unpin + Sync + 'static), ) -> Result<<<LoadTransformAndSave<Loader, Transformer, 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.