keket 0.20.3

Database-like Asset management on top of ECS storage
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

use anput::bundle::DynamicBundle;
use keket::{
    database::{AssetDatabase, path::AssetPathStatic},
    fetch::{AssetBytesAreReadyToProcess, future::FutureAssetFetch},
    protocol::bytes::BytesAssetProtocol,
};
use std::{error::Error, path::PathBuf};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    /* ANCHOR: main */
    let mut database = AssetDatabase::default()
        .with_protocol(BytesAssetProtocol)
        // Future asset fetch uses async function to handle providing
        // asset bytes asynchronously with async/await.
        .with_fetch(FutureAssetFetch::new(tokio_load_file_bundle));

    let package = database.ensure("bytes://package.zip")?;

    // Run maintain passes to load and process loaded bytes.
    while !package.is_ready_to_use(&database) {
        database.maintain()?;
        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
    }

    println!(
        "Package byte size: {}",
        package.access::<&Vec<u8>>(&database).len()
    );
    /* ANCHOR_END: main */

    Ok(())
}

/* ANCHOR: async_read_file */
async fn tokio_load_file_bundle(path: AssetPathStatic) -> Result<DynamicBundle, Box<dyn Error>> {
    let file_path = PathBuf::from("resources").join(path.path());

    let bytes = tokio::fs::read(&file_path).await?;

    let mut bundle = DynamicBundle::default();
    bundle
        .add_component(AssetBytesAreReadyToProcess(bytes))
        .map_err(|_| format!("Failed to add bytes to bundle for asset: {path}"))?;
    Ok(bundle)
}
/* ANCHOR_END: async_read_file */