Struct bevy_asset::processor::LoadTransformAndSave
source · pub struct LoadTransformAndSave<L: AssetLoader, T: AssetTransformer<AssetInput = L::Asset>, S: AssetSaver<Asset = T::AssetOutput>> { /* private fields */ }
Expand description
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§
source§impl<L: AssetLoader, T: AssetTransformer<AssetInput = L::Asset>, S: AssetSaver<Asset = T::AssetOutput>> LoadTransformAndSave<L, T, S>
impl<L: AssetLoader, T: AssetTransformer<AssetInput = L::Asset>, S: AssetSaver<Asset = T::AssetOutput>> LoadTransformAndSave<L, T, S>
Trait Implementations§
source§impl<Loader, Transformer, Saver> Process for LoadTransformAndSave<Loader, Transformer, Saver>where
Loader: AssetLoader,
Transformer: AssetTransformer<AssetInput = Loader::Asset>,
Saver: AssetSaver<Asset = Transformer::AssetOutput>,
impl<Loader, Transformer, Saver> Process for LoadTransformAndSave<Loader, Transformer, Saver>where
Loader: AssetLoader,
Transformer: AssetTransformer<AssetInput = Loader::Asset>,
Saver: AssetSaver<Asset = Transformer::AssetOutput>,
§type Settings = LoadTransformAndSaveSettings<<Loader as AssetLoader>::Settings, <Transformer as AssetTransformer>::Settings, <Saver as AssetSaver>::Settings>
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
type OutputLoader = <Saver as AssetSaver>::OutputLoader
The
AssetLoader
that will be used to load the final processed asset.source§async fn process<'a>(
&'a self,
context: &'a mut ProcessContext<'_>,
meta: AssetMeta<(), Self>,
writer: &'a mut Writer
) -> Result<<Self::OutputLoader as AssetLoader>::Settings, ProcessError>
async fn process<'a>( &'a self, context: &'a mut ProcessContext<'_>, meta: AssetMeta<(), Self>, writer: &'a mut Writer ) -> Result<<Self::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
.Auto Trait Implementations§
impl<L, T, S> Freeze for LoadTransformAndSave<L, T, S>
impl<L, T, S> RefUnwindSafe for LoadTransformAndSave<L, T, S>where
T: RefUnwindSafe,
S: RefUnwindSafe,
impl<L, T, S> Send for LoadTransformAndSave<L, T, S>
impl<L, T, S> Sync for LoadTransformAndSave<L, T, S>
impl<L, T, S> Unpin for LoadTransformAndSave<L, T, S>
impl<L, T, S> UnwindSafe for LoadTransformAndSave<L, T, S>where
T: UnwindSafe,
S: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
source§impl<P> ErasedProcessor for Pwhere
P: Process,
impl<P> ErasedProcessor for Pwhere
P: Process,
source§fn process<'a>(
&'a self,
context: &'a mut ProcessContext<'_>,
meta: Box<dyn AssetMetaDyn>,
writer: &'a mut (dyn AsyncWrite + Unpin + Sync + Send + 'static)
) -> Pin<Box<dyn ConditionalSendFuture<Output = Result<Box<dyn AssetMetaDyn>, ProcessError>> + 'a>>
fn process<'a>( &'a self, context: &'a mut ProcessContext<'_>, meta: Box<dyn AssetMetaDyn>, writer: &'a mut (dyn AsyncWrite + Unpin + Sync + Send + 'static) ) -> Pin<Box<dyn ConditionalSendFuture<Output = Result<Box<dyn AssetMetaDyn>, ProcessError>> + 'a>>
Type-erased variant of
Process::process
.