bevy_wasm_modding 0.19.0

Run WASM systems for modding in Bevy
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Implements loader for a custom asset type.
use bevy::{
    asset::{io::Reader, AssetLoader, LoadedAsset, LoadContext},
    prelude::*,
    reflect::TypePath,
    tasks::BoxedFuture,
};
use thiserror::Error;

use tracing::{error, info, warn};
use serde::Deserialize;
use bevy_wasm_modding_shared::resource_id::{ResourceId, resource_id};
// #[uuid = "4e2a45df-246a-4ab8-91ac-c24218d6a79d"]
#[derive(Asset, Debug, Deserialize, TypePath)]
pub struct WasmAsset {
    pub bytes: Vec<u8>,
}
impl WasmAsset {
    /// Deterministic resource ID for WASM asset system
    pub fn get_resource_id() -> ResourceId {
        resource_id::<WasmAsset>()
    }
}


#[derive(Default, TypePath)]
pub struct WasmAssetLoader;
/*
impl AssetLoader for WasmAssetLoader {

    type Asset = WasmAsset;
    type Settings = ();
    type Error = CustomAssetLoaderError;

    fn load<'a>(
        &'a self,
        bytes: &'a [u8],
       // load_context: &'a mut LoadContext,
        load_context: &mut LoadContext<'_>,
        //  ) -> BoxedFuture<'a, Result<(), bevy::asset::Error>> {
    ) -> BoxedFuture<'a, Result<(), Self::Error>> {
        Box::pin(async move {
            load_context.set_default_asset(LoadedAsset::new(WasmAsset {
                bytes: bytes.into(),
            }));
            Ok(())
        })
    }

    fn extensions(&self) -> &[&str] {
        &["wasm"]
    }
}
*/
/*
#[non_exhaustive]
#[derive(Debug, Error)]
pub enum CustomAssetLoaderError {
    #[error("Could not load asset: {0}")]
    Io(#[from] std::io::Error),
}
*/
/*
#[non_exhaustive]
#[derive(Debug, Error)]
pub enum CustomAssetLoaderError {
    #[error("Could not load asset: {0}")]
    Io(#[from] std::io::Error),
}
*/
impl AssetLoader for WasmAssetLoader {
    type Asset = WasmAsset;
    type Settings = ();
    type Error = CustomAssetLoaderError;

    async fn load(
        &self,
        reader: &mut dyn Reader,
        _settings: &Self::Settings,
        _load_context: &mut LoadContext<'_>,
    ) -> Result<Self::Asset, Self::Error> {
        let mut bytes = Vec::new();
        reader.read_to_end(&mut bytes).await?;
        Ok(WasmAsset { bytes })
    }

    fn extensions(&self) -> &[&str] {
        &["wasm"]
    }
}
#[non_exhaustive]
#[derive(Debug, Error)]
pub enum CustomAssetLoaderError {
    #[error("Could not load asset: {0}")]
    Io(#[from] std::io::Error),
}