bsp_loader: move loader files to map-tool + remove hardcoded file reads

map-tool/src/source/cli.rs

@@ -63,7 +63,7 @@ enum ExtractTextureError{
 	#[error("Bsp error {0:?}")]
 	Bsp(#[from]vbsp::BspError),
 	#[error("MeshLoad error {0:?}")]
-	MeshLoad(#[from]strafesnet_bsp_loader::loader::MeshError),
+	MeshLoad(#[from]super::loader::MeshError),
 	#[error("Load VMT error {0:?}")]
 	LoadVMT(#[from]LoadVMTError),
 }
@@ -136,7 +136,7 @@ async fn gimme_them_textures(path:&std::path::Path,vpk_list:&[strafesnet_bsp_loa
 		vpks:vpk_list
 	};
 
-	let mut mesh_loader=strafesnet_bsp_loader::loader::ModelLoader::new(finder);
+	let mut mesh_loader=super::loader::ModelLoader::new(finder);
 	// load models and collect requested textures
 	for model_path in mesh_deferred_loader.into_indices(){
 		let model:vmdl::Model=match mesh_loader.load(model_path){

map-tool/src/source/loader.rs

@@ -0,0 +1,162 @@
+use std::{borrow::Cow, io::Read};
+
+use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
+
+use strafesnet_bsp_loader::{Bsp,Vpk};
+
+#[derive(Debug)]
+pub enum TextureError{
+	Io(std::io::Error),
+}
+impl std::fmt::Display for TextureError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for TextureError{}
+impl From<std::io::Error> for TextureError{
+	fn from(value:std::io::Error)->Self{
+		Self::Io(value)
+	}
+}
+
+pub struct TextureLoader;
+impl TextureLoader{
+	pub fn new()->Self{
+		Self
+	}
+}
+impl Loader for TextureLoader{
+	type Error=TextureError;
+	type Index<'a>=Cow<'a,str>;
+	type Resource=Texture;
+	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+		let file_name=format!("textures/{}.dds",index);
+		let mut file=std::fs::File::open(file_name)?;
+		let mut data=Vec::new();
+		file.read_to_end(&mut data)?;
+		Ok(Texture::ImageDDS(data))
+	}
+}
+
+#[derive(Debug)]
+pub enum MeshError{
+	Io(std::io::Error),
+	VMDL(vmdl::ModelError),
+	VBSP(vbsp::BspError),
+	MissingMdl(String),
+	MissingVtx,
+	MissingVvd,
+}
+impl std::fmt::Display for MeshError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for MeshError{}
+impl From<std::io::Error> for MeshError{
+	fn from(value:std::io::Error)->Self{
+		Self::Io(value)
+	}
+}
+impl From<vmdl::ModelError> for MeshError{
+	fn from(value:vmdl::ModelError)->Self{
+		Self::VMDL(value)
+	}
+}
+impl From<vbsp::BspError> for MeshError{
+	fn from(value:vbsp::BspError)->Self{
+		Self::VBSP(value)
+	}
+}
+
+#[derive(Clone,Copy)]
+pub struct BspFinder<'bsp,'vpk>{
+	pub bsp:&'bsp Bsp,
+	pub vpks:&'vpk [Vpk],
+}
+impl<'bsp,'vpk> BspFinder<'bsp,'vpk>{
+	pub fn find<'a>(&self,path:&str)->Result<Option<Cow<'a,[u8]>>,vbsp::BspError>
+		where
+			'bsp:'a,
+			'vpk:'a,
+	{
+		// search bsp
+		if let Some(data)=self.bsp.pack_get(path)?{
+			return Ok(Some(Cow::Owned(data)));
+		}
+
+		//search each vpk
+		for vpk in self.vpks{
+			if let Some(vpk_entry)=vpk.tree_get(path){
+				return Ok(Some(vpk_entry.get()?));
+			}
+		}
+
+		Ok(None)
+	}
+}
+
+pub struct ModelLoader<'bsp,'vpk>{
+	finder:BspFinder<'bsp,'vpk>,
+}
+impl ModelLoader<'_,'_>{
+	#[inline]
+	pub const fn new<'bsp,'vpk>(
+		finder:BspFinder<'bsp,'vpk>,
+	)->ModelLoader<'bsp,'vpk>{
+		ModelLoader{
+			finder,
+		}
+	}
+}
+impl Loader for ModelLoader<'_,'_>{
+	type Error=MeshError;
+	type Index<'a>=&'a str where Self:'a;
+	type Resource=vmdl::Model;
+	fn load<'a>(&'a mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+		let mdl_path_lower=index.to_lowercase();
+		//.mdl, .vvd, .dx90.vtx
+		let path=std::path::PathBuf::from(mdl_path_lower.as_str());
+		let mut vvd_path=path.clone();
+		let mut vtx_path=path;
+		vvd_path.set_extension("vvd");
+		vtx_path.set_extension("dx90.vtx");
+		// TODO: search more packs, possibly using an index of multiple packs
+		let mdl=self.finder.find(mdl_path_lower.as_str())?.ok_or(MeshError::MissingMdl(mdl_path_lower))?;
+		let vtx=self.finder.find(vtx_path.as_os_str().to_str().unwrap())?.ok_or(MeshError::MissingVtx)?;
+		let vvd=self.finder.find(vvd_path.as_os_str().to_str().unwrap())?.ok_or(MeshError::MissingVvd)?;
+		Ok(vmdl::Model::from_parts(
+			vmdl::mdl::Mdl::read(mdl.as_ref())?,
+			vmdl::vtx::Vtx::read(vtx.as_ref())?,
+			vmdl::vvd::Vvd::read(vvd.as_ref())?,
+		))
+	}
+}
+
+pub struct MeshLoader<'bsp,'vpk,'load,'str>{
+	finder:BspFinder<'bsp,'vpk>,
+	deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'str,str>>,
+}
+impl MeshLoader<'_,'_,'_,'_>{
+	#[inline]
+	pub const fn new<'bsp,'vpk,'load,'str>(
+		finder:BspFinder<'bsp,'vpk>,
+		deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'str,str>>,
+	)->MeshLoader<'bsp,'vpk,'load,'str>{
+		MeshLoader{
+			finder,
+			deferred_loader
+		}
+	}
+}
+impl Loader for MeshLoader<'_,'_,'_,'_>{
+	type Error=MeshError;
+	type Index<'a>=&'a str where Self:'a;
+	type Resource=strafesnet_bsp_loader::mesh::Mesh;
+	fn load<'a>(&'a mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+		let model=ModelLoader::new(self.finder).load(index)?;
+		let mesh=strafesnet_bsp_loader::mesh::convert_mesh(model,&mut self.deferred_loader);
+		Ok(mesh)
+	}
+}

map-tool/src/source/mod.rs

@@ -2,12 +2,14 @@
 mod cli;
 #[cfg(feature="cli")]
 pub use cli::Commands;
+#[cfg(feature="cli")]
+mod loader;
 
 use std::path::PathBuf;
 use std::borrow::Cow;
 use std::io::Cursor;
-use strafesnet_bsp_loader::loader::BspFinder;
-use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
+use loader::BspFinder;
+use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
 
 enum VMTContent{
 	VMT(String),
@@ -182,7 +184,8 @@ pub enum ConvertError{
 	IO(std::io::Error),
 	SNFMap(strafesnet_snf::map::Error),
 	BspRead(strafesnet_bsp_loader::ReadError),
-	BspLoad(strafesnet_bsp_loader::LoadError),
+	BspLoadMesh(loader::MeshError),
+	BspLoadTexture(loader::TextureError),
 }
 impl std::fmt::Display for ConvertError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -192,11 +195,29 @@ impl std::fmt::Display for ConvertError{
 impl std::error::Error for ConvertError{}
 
 pub fn convert_to_snf(bsp_data:&[u8],vpk_list:&[strafesnet_bsp_loader::Vpk])->Result<Vec<u8>,ConvertError>{
+	const FAILURE_MODE:LoadFailureMode=LoadFailureMode::DefaultToNone;
 	let bsp=strafesnet_bsp_loader::read(
 		Cursor::new(bsp_data)
 	).map_err(ConvertError::BspRead)?;
 
-	let map=bsp.to_snf(LoadFailureMode::DefaultToNone,vpk_list).map_err(ConvertError::BspLoad)?;
+	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
+	let mut mesh_deferred_loader=MeshDeferredLoader::new();
+
+	let map_step1=strafesnet_bsp_loader::bsp::convert(
+		&bsp,
+		&mut texture_deferred_loader,
+		&mut mesh_deferred_loader,
+	);
+
+	let mut mesh_loader=loader::MeshLoader::new(BspFinder{bsp:&bsp,vpks:vpk_list},&mut texture_deferred_loader);
+	let prop_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,FAILURE_MODE).map_err(ConvertError::BspLoadMesh)?;
+
+	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(ConvertError::BspLoadTexture)?;
+
+	let map=map_step2.add_render_configs_and_textures(render_configs);
 
 	let mut snf_buf=Vec::new();
 	strafesnet_snf::map::write_map(Cursor::new(&mut snf_buf),map).map_err(ConvertError::SNFMap)?;