multi_asset_sync.rs:
use std::{
f32::consts::PI,
ops::Drop,
sync::{
atomic::{AtomicBool, AtomicU32, Ordering},
Arc,
},
};
use bevy::{gltf::Gltf, prelude::*, tasks::AsyncComputeTaskPool};
use event_listener::Event;
use futures_lite::Future;
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.init_state::<LoadingState>()
.insert_resource(AmbientLight {
color: Color::WHITE,
brightness: 2000.,
})
.add_systems(Startup, setup_assets)
.add_systems(Startup, setup_scene)
.add_systems(Startup, setup_ui)
.add_systems(Update, wait_on_load.run_if(assets_loaded))
.add_systems(
Update,
get_async_loading_state.run_if(in_state(LoadingState::Loading)),
)
.add_systems(
OnExit(LoadingState::Loading),
despawn_loading_state_entities,
)
.run();
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, States, Default)]
pub enum LoadingState {
#[default]
Loading,
Loaded,
}
#[derive(Debug, Resource)]
pub struct OneHundredThings([Handle<Gltf>; 100]);
#[derive(Debug, Resource, Deref)]
pub struct AssetBarrier(Arc<AssetBarrierInner>);
#[derive(Debug, Deref)]
pub struct AssetBarrierGuard(Arc<AssetBarrierInner>);
#[derive(Debug, Resource)]
pub struct AssetBarrierInner {
count: AtomicU32,
notify: Event,
}
#[derive(Debug, Resource)]
pub struct AsyncLoadingState(Arc<AtomicBool>);
#[derive(Debug, Component)]
pub struct Loading;
#[derive(Debug, Component)]
pub struct LoadingText;
impl AssetBarrier {
pub fn new() -> (AssetBarrier, AssetBarrierGuard) {
let inner = Arc::new(AssetBarrierInner {
count: AtomicU32::new(1),
notify: Event::new(),
});
(AssetBarrier(inner.clone()), AssetBarrierGuard(inner))
}
pub fn is_ready(&self) -> bool {
self.count.load(Ordering::Acquire) == 0
}
pub fn wait_async(&self) -> impl Future<Output = ()> + 'static {
let shared = self.0.clone();
async move {
loop {
let listener = shared.notify.listen();
if shared.count.load(Ordering::Acquire) == 0 {
return;
}
listener.await;
}
}
}
}
impl Clone for AssetBarrierGuard {
fn clone(&self) -> Self {
self.count.fetch_add(1, Ordering::AcqRel);
AssetBarrierGuard(self.0.clone())
}
}
impl Drop for AssetBarrierGuard {
fn drop(&mut self) {
let prev = self.count.fetch_sub(1, Ordering::AcqRel);
if prev == 1 {
self.notify.notify(usize::MAX);
}
}
}
fn setup_assets(mut commands: Commands, asset_server: Res<AssetServer>) {
let (barrier, guard) = AssetBarrier::new();
commands.insert_resource(OneHundredThings(std::array::from_fn(|i| match i % 5 {
0 => asset_server.load_acquire("models/GolfBall/GolfBall.glb", guard.clone()),
1 => asset_server.load_acquire("models/AlienCake/alien.glb", guard.clone()),
2 => asset_server.load_acquire("models/AlienCake/cakeBirthday.glb", guard.clone()),
3 => asset_server.load_acquire("models/FlightHelmet/FlightHelmet.gltf", guard.clone()),
4 => asset_server.load_acquire("models/torus/torus.gltf", guard.clone()),
_ => unreachable!(),
})));
let future = barrier.wait_async();
commands.insert_resource(barrier);
let loading_state = Arc::new(AtomicBool::new(false));
commands.insert_resource(AsyncLoadingState(loading_state.clone()));
AsyncComputeTaskPool::get()
.spawn(async move {
future.await;
loading_state.store(true, Ordering::Release);
})
.detach();
}
fn setup_ui(mut commands: Commands) {
commands.spawn((
LoadingText,
Text::new("Loading...".to_owned()),
Node {
position_type: PositionType::Absolute,
left: Val::Px(12.0),
top: Val::Px(12.0),
..default()
},
));
}
fn setup_scene(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
commands.spawn((
Camera3d::default(),
Transform::from_xyz(10.0, 10.0, 15.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
));
commands.spawn((
DirectionalLight {
shadows_enabled: true,
..default()
},
Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
));
commands.spawn((
Mesh3d(meshes.add(Plane3d::default().mesh().size(50000.0, 50000.0))),
MeshMaterial3d(materials.add(Color::srgb(0.7, 0.2, 0.2))),
Loading,
));
}
fn assets_loaded(barrier: Option<Res<AssetBarrier>>) -> bool {
barrier.map(|b| b.is_ready()) == Some(true)
}
fn wait_on_load(
mut commands: Commands,
foxes: Res<OneHundredThings>,
gltfs: Res<Assets<Gltf>>,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
commands.spawn((
Mesh3d(meshes.add(Plane3d::default().mesh().size(50000.0, 50000.0))),
MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
Transform::from_translation(Vec3::Z * -0.01),
));
for i in 0..10 {
for j in 0..10 {
let index = i * 10 + j;
let position = Vec3::new(i as f32 - 5.0, 0.0, j as f32 - 5.0);
let gltf = gltfs.get(&foxes.0[index]).unwrap();
let scene = gltf.scenes.first().unwrap().clone();
commands.spawn((SceneRoot(scene), Transform::from_translation(position)));
}
}
}
fn get_async_loading_state(
state: Res<AsyncLoadingState>,
mut next_loading_state: ResMut<NextState<LoadingState>>,
mut text: Query<&mut Text, With<LoadingText>>,
) {
let is_loaded = state.0.load(Ordering::Acquire);
if is_loaded {
next_loading_state.set(LoadingState::Loaded);
if let Ok(mut text) = text.get_single_mut() {
"Loaded!".clone_into(&mut **text);
}
}
}
fn despawn_loading_state_entities(mut commands: Commands, loading: Query<Entity, With<Loading>>) {
for entity in loading.iter() {
commands.entity(entity).despawn_recursive();
}
commands.remove_resource::<AssetBarrier>();
commands.remove_resource::<AsyncLoadingState>();
}