107 lines
2.7 KiB
Rust
107 lines
2.7 KiB
Rust
pub mod macros {
|
|
|
|
#[macro_export]
|
|
macro_rules! create_asset_loader {
|
|
(
|
|
$plugin_name: ident,
|
|
$loader_name: ident,
|
|
$asset_type: ident,
|
|
$asset_loadstate_name: ident,
|
|
$extensions: expr,
|
|
$($string_name: ident -> $handle_name: ident)* ;
|
|
$($string_array_name: ident -> $handle_array_name: ident)* ?
|
|
) => {
|
|
use bevy::prelude::*;
|
|
use bevy::asset::{AssetLoader, AssetEvent, LoadContext, AsyncReadExt, io::Reader};
|
|
use bevy::utils::BoxedFuture;
|
|
pub struct $plugin_name;
|
|
impl Plugin for $plugin_name {
|
|
fn build(&self, app: &mut App) {
|
|
app.init_asset::<$asset_type>()
|
|
.init_asset_loader::<$loader_name>()
|
|
.insert_resource($asset_loadstate_name::default())
|
|
.add_systems(Update, finalize);
|
|
}
|
|
}
|
|
|
|
fn finalize(
|
|
mut asset_events: EventReader<AssetEvent<$asset_type>>,
|
|
mut assets: ResMut<Assets<$asset_type>>,
|
|
mut load_state: ResMut<$asset_loadstate_name>,
|
|
asset_server: Res<AssetServer>
|
|
) {
|
|
for event in asset_events.read() {
|
|
match event {
|
|
AssetEvent::Added { id } => load_state.added += 1,
|
|
AssetEvent::LoadedWithDependencies { id } => {
|
|
let asset = assets.get_mut(id.clone()).unwrap();
|
|
|
|
$(
|
|
asset.$handle_name = asset_server.load(&asset.$string_name);
|
|
)*
|
|
$(
|
|
for i in 0..asset.$string_array_name.len(){
|
|
asset.$handle_array_name.push(asset_server.load(&asset.$string_array_name[i]));
|
|
}
|
|
)?
|
|
load_state.loaded += 1;
|
|
},
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Resource, Debug, Default)]
|
|
pub struct $asset_loadstate_name{
|
|
pub loaded: u32,
|
|
pub added: u32,
|
|
}
|
|
|
|
impl $asset_loadstate_name{
|
|
pub fn is_all_loaded(&self) -> bool{
|
|
if self.added == 0{
|
|
return false;
|
|
}
|
|
return self.loaded >= self.added;
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct $loader_name;
|
|
|
|
impl AssetLoader for $loader_name {
|
|
type Asset = $asset_type;
|
|
|
|
type Settings = ();
|
|
|
|
type Error = String;
|
|
|
|
fn load<'a>(
|
|
&'a self,
|
|
reader: &'a mut Reader,
|
|
_settings: &'a Self::Settings,
|
|
_load_context: &'a mut LoadContext,
|
|
) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
|
|
return Box::pin(async move {
|
|
let mut data: String = String::new();
|
|
let read_result = reader.read_to_string(&mut data).await;
|
|
if read_result.is_err() {
|
|
return Err(read_result.err().unwrap().to_string());
|
|
}
|
|
let serialized: Result<Self::Asset, serde_json::Error> =
|
|
serde_json::from_str(&data);
|
|
if serialized.is_err() {
|
|
return Err(serialized.err().unwrap().to_string());
|
|
}
|
|
return Ok(serialized.unwrap());
|
|
});
|
|
}
|
|
|
|
fn extensions(&self) -> &[&str] {
|
|
$extensions
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|