Struct AssetInspector 

pub struct AssetInspector<'a> { /* private fields */ }

The AssetInspector struct provides a way to access asset path, its components, as well as dependencies.

Implementations

impl<'a> AssetInspector<'a>

pub fn new(database: &'a AssetDatabase, handle: AssetHandle) -> Self

Creates a new AssetInspector instance for the given asset handle.

Arguments

• database - A reference to the AssetDatabase containing the asset.
• handle - The AssetHandle representing the asset to inspect.

Returns

A new AssetInspector instance.

pub fn new_raw(storage: &'a World, entity: Entity) -> Self

Creates a new AssetInspector instance for the given asset entity.

Arguments

• storage - A reference to the World containing the asset entity.
• entity - The Entity representing the asset to inspect.

Returns

A new AssetInspector instance.

pub fn storage(&self) -> &'a World

Returns a reference to the underlying storage.

pub fn handle(&self) -> AssetHandle

Returns the assigned asset handle.

pub fn path(&self) -> Result<AssetPathStatic, Box<dyn Error>>

Returns the asset path associated with the asset.

pub fn access_checked<Fetch: TypedLookupFetch<'a, true>>( &self, ) -> Option<Fetch::Value>

Tries to access typed data for this asset.

pub fn access<Fetch: TypedLookupFetch<'a, true>>(&self) -> Fetch::Value

Accesses typed data for this asset or panics if it cannot.

Examples found in repository

examples/22_store_custom_asset.rs (line 30)

fn main() -> Result<(), Box<dyn Error>> {
    /* ANCHOR: main */
    let mut database = AssetDatabase::default()
        .with_protocol(BundleAssetProtocol::new(
            "json",
            (
                |bytes: Vec<u8>| {
                    let asset = serde_json::from_slice::<Person>(&bytes)?;
                    Ok((asset,).into())
                },
                // Additionally to decoding asset we can also encode it back to bytes.
                // This is useful for saving assets to storage.
                |inspector: AssetInspector| {
                    let asset = inspector.access::<&Person>();
                    let bytes = serde_json::to_vec(asset)?;
                    Ok(bytes.into())
                },
            ),
        ))
        .with_fetch(FileAssetFetch::default().with_root("resources"))
        .with_store(FileAssetStore::default().with_root("resources"));

    let _ = std::fs::remove_file("./resources/saved.json");

    let before = database.spawn(
        "json://saved.json",
        (Person {
            name: "Alice".to_owned(),
            age: 42,
        },),
    )?;
    println!("Before: {:?}", before.access::<&Person>(&database));
    before.store(&mut database)?;

    while database.is_busy() {
        database.maintain()?;
    }

    before.delete(&mut database);
    assert!(!before.does_exists(&database));

    // Load the asset from storage, we get previously saved asset content.
    let after = database.ensure("json://saved.json")?;
    println!("After: {:?}", after.access::<&Person>(&database));
    /* ANCHOR_END: main */

    Ok(())
}

pub fn dependencies(&'a self) -> impl Iterator<Item = Self> + 'a

Returns an iterator over asset dependencies.

pub fn traverse_dependencies(&'a self) -> impl Iterator<Item = Self> + 'a

Recursively iterates through all assigned asset dependencies.