generic to_snf

lib/bsp_loader/src/lib.rs

@@ -1,9 +1,9 @@
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
+use strafesnet_deferred_loader::loader::Loader;
 
 mod bsp;
 mod mesh;
 mod brush;
-pub mod loader;
 
 const VALVE_SCALE:f32=1.0/16.0;
 pub(crate) fn valve_transform_dist(d:f32)->strafesnet_common::integer::Planar64{
@@ -30,26 +30,25 @@ impl std::error::Error for ReadError{}
 
 
 #[derive(Debug)]
-pub enum LoadError{
-	Texture(loader::TextureError),
-	Mesh(loader::MeshError),
+pub enum LoadError<M,T>{
+	Mesh(M),
+	Texture(T),
 }
-impl std::fmt::Display for LoadError{
+impl<M,T> std::fmt::Display for LoadError<M,T>
+	where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{
 	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)
-	}
-}
+impl<M,T> std::error::Error for LoadError<M,T>
+where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{}
+
 pub struct Bsp{
 	bsp:vbsp::Bsp,
 	case_folded_file_names:std::collections::HashMap<String,String>,
@@ -84,7 +83,17 @@ impl Bsp{
 			None=>Ok(None),
 		}
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode,vpk_list:&[Vpk])->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	pub fn to_snf<'dom,'mesh,'texture,M,T>(
+		&'dom self,
+		failure_mode:LoadFailureMode,
+		mut mesh_loader:M,
+		mut texture_loader:T,
+	)->Result<strafesnet_common::map::CompleteMap,LoadError<M::Error,T::Error>>
+		where
+			'dom:'mesh+'texture,
+			M:Loader<Resource=strafesnet_common::model::Mesh,Index<'mesh>=&'mesh str>+'mesh,
+			T:Loader<Resource=strafesnet_deferred_loader::texture::Texture,Index<'texture>=std::borrow::Cow<'texture,str>>+'texture,
+	{
 		let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
 		let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
@@ -94,12 +103,10 @@ impl Bsp{
 			&mut mesh_deferred_loader,
 		);
 
-		let mut mesh_loader=loader::MeshLoader::new(loader::BspFinder{bsp:self,vpks:vpk_list},&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);

lib/rbx_loader/src/lib.rs

@@ -2,15 +2,18 @@ use rbx_dom_weak::WeakDom;
 use roblox_emulator::context::Context;
 use strafesnet_common::map::CompleteMap;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
+use strafesnet_deferred_loader::loader::Loader;
+use strafesnet_deferred_loader::texture::Texture;
 
 pub use error::RecoverableErrors;
 pub use roblox_emulator::runner::Error as RunnerError;
 
+use crate::loader::{MeshIndex,MeshWithSize};
+
 mod rbx;
 mod mesh;
 mod error;
 mod union;
-pub mod loader;
 pub mod primitives;
 
 pub mod data{
@@ -32,8 +35,18 @@ impl Model{
 	pub fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
-		to_snf(self,failure_mode)
+	pub fn to_snf<'dom,'mesh,'texture,M,T>(
+		&'dom self,
+		failure_mode:LoadFailureMode,
+		mesh_loader:M,
+		texture_loader:T,
+	)->Result<(CompleteMap,RecoverableErrors),LoadError<M::Error,T::Error>>
+		where
+			'dom:'mesh+'texture,
+			M:Loader<Resource=MeshWithSize,Index<'mesh>=MeshIndex<'mesh>>+'mesh,
+			T:Loader<Resource=Texture,Index<'texture>=&'texture str>+'texture,
+	{
+		to_snf(self.as_ref(),failure_mode,mesh_loader,texture_loader)
 	}
 }
 impl AsRef<WeakDom> for Model{
@@ -65,8 +78,18 @@ impl Place{
 		}
 		Ok(errors)
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
-		to_snf(self,failure_mode)
+	pub fn to_snf<'dom,'mesh,'texture,M,T>(
+		&'dom self,
+		failure_mode:LoadFailureMode,
+		mesh_loader:M,
+		texture_loader:T,
+	)->Result<(CompleteMap,RecoverableErrors),LoadError<M::Error,T::Error>>
+		where
+			'dom:'mesh+'texture,
+			M:Loader<Resource=MeshWithSize,Index<'mesh>=MeshIndex<'mesh>>+'mesh,
+			T:Loader<Resource=Texture,Index<'texture>=&'texture str>+'texture,
+	{
+		to_snf(self.as_ref(),failure_mode,mesh_loader,texture_loader)
 	}
 }
 impl AsRef<WeakDom> for Place{
@@ -84,30 +107,36 @@ impl From<Model> for Place{
 }
 
 #[derive(Debug)]
-pub enum LoadError{
-	Texture(loader::TextureError),
-	Mesh(loader::MeshError),
+pub enum LoadError<M,T>{
+	Mesh(M),
+	Texture(T),
 }
-impl std::fmt::Display for LoadError{
+impl<M,T> std::fmt::Display for LoadError<M,T>
+	where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{
 	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)
-	}
-}
-
-fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
-	let dom=dom.as_ref();
+impl<M,T> std::error::Error for LoadError<M,T>
+where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{}
 
+fn to_snf<'dom,'mesh,'texture,M,T>(
+	dom:&'dom WeakDom,
+	failure_mode:LoadFailureMode,
+	mut mesh_loader:M,
+	mut texture_loader:T,
+)->Result<(CompleteMap,RecoverableErrors),LoadError<M::Error,T::Error>>
+	where
+		'dom:'mesh+'texture,
+		M:Loader<Resource=MeshWithSize,Index<'mesh>=MeshIndex<'mesh>>+'mesh,
+		T:Loader<Resource=Texture,Index<'texture>=&'texture str>+'texture,
+{
 	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
 	let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
@@ -117,12 +146,10 @@ fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<(Complet
 		&mut mesh_deferred_loader,
 	);
 
-	let mut mesh_loader=loader::MeshLoader::new();
 	let meshpart_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,failure_mode).map_err(LoadError::Mesh)?;
 
 	let map_step2=map_step1.add_meshpart_meshes_and_calculate_attributes(meshpart_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)?;
 
 	Ok(map_step2.add_render_configs_and_textures(render_configs))

map-tool/src/roblox/mod.rs

@@ -2,6 +2,8 @@
 mod cli;
 #[cfg(feature="cli")]
 pub use cli::Commands;
+#[cfg(feature="cli")]
+mod loader;
 
 use std::io::{Cursor,Read,Seek};
 use std::collections::HashSet;

map-tool/src/source/mod.rs

@@ -2,6 +2,8 @@
 mod cli;
 #[cfg(feature="cli")]
 pub use cli::Commands;
+#[cfg(feature="cli")]
+mod loader;
 
 use std::path::PathBuf;
 use std::borrow::Cow;
@@ -196,7 +198,9 @@ pub fn convert_to_snf(bsp_data:&[u8],vpk_list:&[strafesnet_bsp_loader::Vpk])->Re
 		Cursor::new(bsp_data)
 	).map_err(ConvertError::BspRead)?;
 
-	let map=bsp.to_snf(LoadFailureMode::DefaultToNone,vpk_list).map_err(ConvertError::BspLoad)?;
+	let mut mesh_loader=loader::MeshLoader::new(loader::BspFinder{bsp:self,vpks:vpk_list},&mut texture_deferred_loader);
+	let mut texture_loader=loader::TextureLoader::new();
+	let map=bsp.to_snf(LoadFailureMode::DefaultToNone,mesh_loader,texture_loader).map_err(ConvertError::BspLoad)?;
 
 	let mut snf_buf=Vec::new();
 	strafesnet_snf::map::write_map(Cursor::new(&mut snf_buf),map).map_err(ConvertError::SNFMap)?;