move conversion code into loader libs

lib/bsp_loader/src/lib.rs

@@ -1,19 +1,9 @@
+use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
+
 mod bsp;
 mod mesh;
 pub mod loader;
 
-pub struct Bsp(vbsp::Bsp);
-impl Bsp{
-	pub const fn new(value:vbsp::Bsp)->Self{
-		Self(value)
-	}
-}
-impl AsRef<vbsp::Bsp> for Bsp{
-	fn as_ref(&self)->&vbsp::Bsp{
-		&self.0
-	}
-}
-
 const VALVE_SCALE:f32=1.0/16.0;
 pub(crate) fn valve_transform([x,y,z]:[f32;3])->strafesnet_common::integer::Planar64Vec3{
 	strafesnet_common::integer::vec3::try_from_f32_array([x*VALVE_SCALE,z*VALVE_SCALE,-y*VALVE_SCALE]).unwrap()
@@ -31,6 +21,35 @@ impl std::fmt::Display for ReadError{
 }
 impl std::error::Error for ReadError{}
 
+
+#[derive(Debug)]
+pub enum LoadError{
+	Texture(loader::TextureError),
+	Mesh(loader::MeshError),
+}
+impl std::fmt::Display for LoadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadError{}
+impl From<loader::TextureError> for LoadError{
+	fn from(value:loader::TextureError)->Self{
+		Self::Texture(value)
+	}
+}
+impl From<loader::MeshError> for LoadError{
+	fn from(value:loader::MeshError)->Self{
+		Self::Mesh(value)
+	}
+}
+pub struct Bsp(vbsp::Bsp);
+impl AsRef<vbsp::Bsp> for Bsp{
+	fn as_ref(&self)->&vbsp::Bsp{
+		&self.0
+	}
+}
+
 pub fn read<R:std::io::Read>(mut input:R)->Result<Bsp,ReadError>{
 	let mut s=Vec::new();
 
@@ -39,5 +58,30 @@ pub fn read<R:std::io::Read>(mut input:R)->Result<Bsp,ReadError>{
 
 	vbsp::Bsp::read(s.as_slice()).map(Bsp::new).map_err(ReadError::Bsp)
 }
+impl Bsp{
+	pub const fn new(value:vbsp::Bsp)->Self{
+		Self(value)
+	}
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+		let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
+		let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
-pub use bsp::convert;
+		let map_step1=bsp::convert(
+			self,
+			&mut texture_deferred_loader,
+			&mut mesh_deferred_loader,
+		);
+
+		let mut mesh_loader=loader::MeshLoader::new(self,&mut texture_deferred_loader);
+		let prop_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,failure_mode).map_err(LoadError::Mesh)?;
+
+		let map_step2=map_step1.add_prop_meshes(prop_meshes);
+
+		let mut texture_loader=loader::TextureLoader::new();
+		let render_configs=texture_deferred_loader.into_render_configs(&mut texture_loader,failure_mode).map_err(LoadError::Texture)?;
+
+		let map=map_step2.add_render_configs_and_textures(render_configs);
+
+		Ok(map)
+	}
+}