bevy_chair 0.10.0

use crate::{
	atlas::*,
	vertex::*
};

use std::sync::Mutex;

use anyhow::{Context, Result};
use bevy_asset::*;
use bevy_render::{
	mesh::{Indices, Mesh},
	render_resource::PrimitiveTopology
};
use bevy_utils::BoxedFuture;
use cached::proc_macro::once;
use chair::{MeshFeature, MeshReader};
use tokio::sync::oneshot::Receiver;

pub struct ChairLoader {
	atlas_rx: Mutex<Option<Receiver<ChairAtlas>>>
}

impl ChairLoader {
	pub fn new(rx: Receiver<ChairAtlas>) -> Self {
		Self {
			atlas_rx: Mutex::new(Some(rx))
		}
	}
}

impl AssetLoader for ChairLoader {
	fn load<'ctx>(&'ctx self, bytes: &'ctx [u8], load_context: &'ctx mut LoadContext) -> BoxedFuture<'ctx, Result<()>> {
		Box::pin(async move {
			let atlas = get_atlas(&self.atlas_rx).await;
			let reader = MeshReader::new::<FatVertex>(atlas.0, Some("error"));
			let (features, vertices, indices) = reader.read::<FatVertex>(bytes)
				.context("Failed to load mesh")?;

			// assemble the mesh struct depending on what features were enabled
			let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
			mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, vertices.iter()
				.map(|v| v.pos)
				.collect::<Vec<_>>());
			if features.contains(MeshFeature::Coloured) {
				mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, vertices.iter()
					.map(|v| v.col)
					.collect::<Vec<_>>());
			}
			if features.contains(MeshFeature::Normals) {
				mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vertices.iter()
					.map(|v| v.normals)
					.collect::<Vec<_>>());
			}
			if features.contains(MeshFeature::Textured) {
				mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, vertices.iter()
					.map(|v| {
						let u = v.uvs;
						[1.0 - u[0], u[1]]
					})
					.collect::<Vec<_>>());
			}

			mesh.set_indices(Some(Indices::U32(indices)));

			load_context.set_default_asset(LoadedAsset::new(mesh));

			Ok(())
		})
	}

	fn extensions(&self) -> &[&str] {
		&["chr"]
	}
}

// cached in a way that it will only ever run once, and return the same reference each time
#[once(sync_writes = true)]
async fn get_atlas(rx: &Mutex<Option<Receiver<ChairAtlas>>>) -> ChairAtlas {
	let rx = {
		let mut lock = rx.lock().unwrap();
		lock.take()
			.expect("get_atlas called multiple times, bug in cached?")
	};

	rx.await
		.expect("Receiving atlas failed")
}