Struct AssetTreeProcessor 

pub struct AssetTreeProcessor<T: AssetTree> { /* private fields */ }

AssetTreeProcessor is a processor for components that implement the AssetTree trait. It allows deserializing and serializing assets, as well as processing them with dependencies based on what their asset_dependencies method reports.

Implementations

impl<T: AssetTree> AssetTreeProcessor<T>

pub fn new( deserializer: impl FnMut(Vec<u8>) -> Result<T, Box<dyn Error>> + Send + Sync + 'static, ) -> Self

Creates a new AssetTreeProcessor with the given deserializer.

The deserializer is a function that takes a Vec<u8> and returns a Result<T, Box<dyn Error>>, where T is the type of the asset tree component.

Arguments

• deserializer: A function that deserializes bytes into an asset tree component of type T.

Returns

A new instance of AssetTreeProcessor.

Examples found in repository

examples/hello_graph.rs (lines 22-24)

fn main() -> Result<(), Box<dyn Error>> {
    // /* ANCHOR: main */
    let mut database = AssetDatabase::default()
        .with_protocol(BundleAssetProtocol::new(
            "custom",
            // AssetTreeProcessor handles deserialization of the custom asset
            // as single component. That component will report its dependencies
            // to load.
            AssetTreeProcessor::<CustomAsset>::new(|bytes| {
                Ok(serde_json::from_slice::<CustomAsset>(&bytes)?)
            }),
        ))
        .with_fetch(FileAssetFetch::default().with_root("resources"));

    // Create asset node and ensure it is being loaded.
    let asset = AssetNode::<CustomAsset>::new("custom://part1.json");
    asset.ensure(&mut database)?;

    // Wait until the database is not busy, which means all assets are loaded.
    while database.is_busy() {
        database.maintain()?;
    }

    // Resolve the asset and read its contents.
    // This will also resolve all dependencies of the asset.
    let contents = asset
        .resolve(&database)?
        .read_unchecked()
        .contents(&database);
    println!("Custom chain contents: {contents:?}");
    // /* ANCHOR_END: main */
    Ok(())
}

pub fn with_serializer( self, serializer: impl FnMut(&T) -> Result<Vec<u8>, Box<dyn Error>> + Send + Sync + 'static, ) -> Self

Sets a serializer for the asset tree component.

This method allows you to provide a function that serializes an asset tree component of type T into a Vec<u8>. The serializer must be a function that takes a reference to T and returns a Result<Vec<u8>, Box<dyn Error>>.

Arguments

• serializer: A function that serializes an asset tree component of type T into a Vec<u8>.

Returns

A mutable reference to Self, allowing for method chaining.

Trait Implementations

impl<T: AssetTree> BundleWithDependenciesProcessor for AssetTreeProcessor<T>

type Bundle = (T,)

Returned bundle of asset components.

fn process_bytes( &mut self, bytes: Vec<u8>, ) -> Result<BundleWithDependencies<Self::Bundle>, Box<dyn Error>>

Processes a vector of bytes and returns a BundleWithDependencies.

fn produce_bytes( &mut self, inspector: AssetInspector<'_>, ) -> Result<StoreWithDependencies, Box<dyn Error>>

Produces bytes using given AssetInspector.

fn extract_bundle_from_path( &self, path: &AssetPath<'_>, ) -> Result<DynamicBundle, Box<dyn Error>>

Extracts a DynamicBundle from the given AssetPath.

fn rewrite_path( &self, path: AssetPath<'static>, ) -> Result<AssetPath<'static>, Box<dyn Error>>

Rewrites the asset path before spawning asset in storage.

fn maintain(&mut self, storage: &mut World) -> Result<(), Box<dyn Error>>

Maintains internal state of processor.