the errors went away but im not done

lib/rbx_loader/src/loader.rs

@@ -5,6 +5,13 @@ use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
 
 use crate::data::RobloxMeshBytes;
 
+fn read_entire_file(path:impl AsRef<std::path::Path>)->Result<Vec<u8>,std::io::Error>{
+	let mut file=std::fs::File::open(path)?;
+	let mut data=Vec::new();
+	file.read_to_end(&mut data)?;
+	Ok(data)
+}
+
 #[allow(dead_code)]
 #[derive(Debug)]
 pub enum TextureError{
@@ -41,9 +48,7 @@ impl<'a> Loader for TextureLoader<'a>{
 	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
 		let RobloxAssetId(asset_id)=index.parse()?;
 		let file_name=format!("textures/{}.dds",asset_id);
-		let mut file=std::fs::File::open(file_name)?;
+		let data=read_entire_file(file_name)?;
-		let mut data=Vec::new();
-		file.read_to_end(&mut data)?;
 		Ok(Texture::ImageDDS(data))
 	}
 }
@@ -53,7 +58,8 @@ impl<'a> Loader for TextureLoader<'a>{
 pub enum MeshError{
 	Io(std::io::Error),
 	RobloxAssetIdParse(RobloxAssetIdParseErr),
-	Mesh(crate::mesh::Error)
+	Mesh(crate::mesh::Error),
+	Union(crate::union::Error),
 
 }
 impl std::fmt::Display for MeshError{
@@ -77,6 +83,43 @@ impl From<crate::mesh::Error> for MeshError{
 		Self::Mesh(value)
 	}
 }
+impl From<crate::union::Error> for MeshError{
+	fn from(value:crate::union::Error)->Self{
+		Self::Union(value)
+	}
+}
+
+#[derive(Hash,Eq,PartialEq)]
+pub enum MeshType<'a>{
+	FileMesh,
+	Union{
+		mesh_data:&'a [u8],
+		physics_data:&'a [u8],
+	},
+}
+#[derive(Hash,Eq,PartialEq)]
+pub struct MeshIndex<'a>{
+	mesh_type:MeshType<'a>,
+	content:&'a str,
+}
+impl MeshIndex<'_>{
+	pub fn file_mesh(content:&str)->MeshIndex{
+		MeshIndex{
+			mesh_type:MeshType::FileMesh,
+			content,
+		}
+	}
+	pub fn union<'a>(
+		content:&'a str,
+		mesh_data:&'a [u8],
+		physics_data:&'a [u8],
+	)->MeshIndex<'a>{
+		MeshIndex{
+			mesh_type:MeshType::Union{mesh_data,physics_data},
+			content,
+		}
+	}
+}
 
 pub struct MeshLoader<'a>(std::marker::PhantomData<&'a ()>);
 impl MeshLoader<'_>{
@@ -86,17 +129,18 @@ impl MeshLoader<'_>{
 }
 impl<'a> Loader for MeshLoader<'a>{
 	type Error=MeshError;
-	type Index=&'a str;
+	type Index=MeshIndex<'a>;
 	type Resource=Mesh;
 	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
-		let RobloxAssetId(asset_id)=index.parse()?;
+		let RobloxAssetId(asset_id)=index.content.parse()?;
 		let file_name=format!("meshes/{}",asset_id);
-		let mut file=std::fs::File::open(file_name)?;
 		// reading the entire file is way faster than
 		// round tripping to disk every read from the parser
-		let mut data=Vec::new();
+		let data=read_entire_file(file_name)?;
-		file.read_to_end(&mut data)?;
+		let mesh=match index.mesh_type{
-		let mesh=crate::mesh::convert(RobloxMeshBytes::new(data))?;
+			MeshType::FileMesh=>crate::mesh::convert(RobloxMeshBytes::new(data))?,
+			MeshType::Union{physics_data,mesh_data}=>crate::union::convert(physics_data,mesh_data)?,
+		};
 		Ok(mesh)
 	}
 }

lib/rbx_loader/src/rbx.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use crate::loader::MeshIndex;
 use crate::primitives;
 use strafesnet_common::map;
 use strafesnet_common::model;
@@ -487,31 +488,24 @@ enum Shape{
 	MeshPart,
 	PhysicsData,
 }
-enum MeshAvailability<'a>{
+enum MeshAvailability{
 	Immediate,
 	DeferredMesh(RenderConfigId),
-	DeferredUnion(RobloxPartDescription,UnionDeferredAttributes<'a>),
+	DeferredUnion(RobloxPartDescription),
 }
-struct DeferredModelDeferredAttributes{
+struct DeferredModelDeferredAttributes<'a>{
 	render:RenderConfigId,
-	model:ModelDeferredAttributes,
+	model:ModelDeferredAttributes<'a>,
 }
-struct ModelDeferredAttributes{
+struct ModelDeferredAttributes<'a>{
 	mesh:model::MeshId,
-	deferred_attributes:GetAttributesArgs,
+	deferred_attributes:GetAttributesArgs<'a>,
 	color:model::Color4,//transparency is in here
 	transform:Planar64Affine3,
 }
 struct DeferredUnionDeferredAttributes<'a>{
 	render:RobloxPartDescription,
-	model:ModelDeferredAttributes,
+	model:ModelDeferredAttributes<'a>,
-	union:UnionDeferredAttributes<'a>,
-}
-#[derive(Hash)]
-struct UnionDeferredAttributes<'a>{
-	asset_id:Option<&'a str>,
-	mesh_data:Option<&'a [u8]>,
-	physics_data:Option<&'a [u8]>,
 }
 struct ModelOwnedAttributes{
 	mesh:model::MeshId,
@@ -519,17 +513,18 @@ struct ModelOwnedAttributes{
 	color:model::Color4,//transparency is in here
 	transform:Planar64Affine3,
 }
-struct GetAttributesArgs{
+struct GetAttributesArgs<'a>{
-	name:Box<str>,
+	name:&'a str,
 	can_collide:bool,
 	velocity:Planar64Vec3,
 }
 pub fn convert<'a>(
 	dom:&'a rbx_dom_weak::WeakDom,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
-	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
+	mesh_deferred_loader:&mut MeshDeferredLoader<MeshIndex<'a>>,
 )->PartialMap1<'a>{
 	let mut deferred_models_deferred_attributes=Vec::new();
+	let mut deferred_unions_deferred_attributes=Vec::new();
 	let mut primitive_models_deferred_attributes=Vec::new();
 	let mut primitive_meshes=Vec::new();
 	let mut mesh_id_from_description=HashMap::new();
@@ -600,7 +595,7 @@ pub fn convert<'a>(
 				let (availability,mesh_id)=match shape{
 					Shape::Primitive(primitive_shape)=>{
 				//TODO: TAB TAB
-				let part_texture_description=get_texture_description(&mut temp_objects,&mut render_config_deferred_loader,dom,object,size);
+				let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
 				//obscure rust syntax "slice pattern"
 				let [
 					f0,//Cube::Right
@@ -714,7 +709,7 @@ pub fn convert<'a>(
 					){
 						(
 							MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(Some(texture_asset_id.as_ref()))),
-							mesh_deferred_loader.acquire_mesh_id(mesh_asset_id.as_ref()),
+							mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id.as_ref())),
 						)
 					}else{
 						panic!("Mesh has no Mesh or Texture");
@@ -723,34 +718,22 @@ pub fn convert<'a>(
 						//The union mesh is sized already
 						model_transform=planar64_affine3_from_roblox(cf,&rbx_dom_weak::types::Vector3{x:2.0,y:2.0,z:2.0});
 
-						let mut asset_id=None;
+						let mut content="";
-						let mut mesh_data=None;
+						let mut mesh_data:&[u8]=&[];
-						let mut physics_data=None;
+						let mut physics_data:&[u8]=&[];
-						if let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get("AssetId"){
+						if let Some(rbx_dom_weak::types::Variant::Content(asset_id))=object.properties.get("AssetId"){
-							let value:&str=content.as_ref();
+							content=asset_id.as_ref();
-							if !value.is_empty(){
-								asset_id=Some(value);
-							}
 						}
 						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("MeshData"){
-							let value:&[u8]=data.as_ref();
+							mesh_data=data.as_ref();
-							if !value.is_empty(){
-								mesh_data=Some(value);
-							}
 						}
 						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("PhysicsData"){
-							let value:&[u8]=data.as_ref();
+							physics_data=data.as_ref();
-							if !value.is_empty(){
-								physics_data=Some(value);
-							}
 						}
-						let part_texture_description=get_texture_description(&mut temp_objects,&mut render_config_deferred_loader,dom,object,size);
+						let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
-						let union_deferred_attributes=UnionDeferredAttributes{
+						let mesh_index=MeshIndex::union(content,mesh_data,physics_data);
-							asset_id,
+						let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
-							mesh_data,
+						(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
-							physics_data,
-						};
-						(MeshAvailability::DeferredUnion(part_texture_description,union_deferred_attributes),mesh_id)
 					},
 				};
 				let model_deferred_attributes=ModelDeferredAttributes{
@@ -758,7 +741,7 @@ pub fn convert<'a>(
 					transform:model_transform,
 					color:glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
 					deferred_attributes:GetAttributesArgs{
-						name:object.name.as_str().into(),
+						name:object.name.as_str(),
 						can_collide:*can_collide,
 						velocity:vec3::try_from_f32_array([velocity.x,velocity.y,velocity.z]).unwrap(),
 					},
@@ -769,10 +752,9 @@ pub fn convert<'a>(
 						render,
 						model:model_deferred_attributes
 					}),
-					MeshAvailability::DeferredUnion(part_texture_description,union_deferred_attributes)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
+					MeshAvailability::DeferredUnion(part_texture_description)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
 						render:part_texture_description,
 						model:model_deferred_attributes,
-						union:union_deferred_attributes,
 					}),
 				}
 			}
@@ -782,6 +764,7 @@ pub fn convert<'a>(
 		primitive_meshes,
 		primitive_models_deferred_attributes,
 		deferred_models_deferred_attributes,
+		deferred_unions_deferred_attributes,
 	}
 }
 struct MeshWithAabb{
@@ -790,11 +773,11 @@ struct MeshWithAabb{
 }
 pub struct PartialMap1<'a>{
 	primitive_meshes:Vec<model::Mesh>,
-	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes>,
+	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes<'a>>,
-	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
+	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes<'a>>,
-	deferred_union_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
+	deferred_unions_deferred_attributes:Vec<DeferredUnionDeferredAttributes<'a>>,
 }
-impl PartialMap1{
+impl PartialMap1<'_>{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
 		mut self,
 		meshpart_meshes:Meshes,

lib/rbx_loader/src/union.rs

@@ -33,7 +33,7 @@ pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8])->Result<model::
 		std::io::Cursor::new(roblox_mesh_data)
 	).map_err(Error::RobloxMeshData)?;
 	let graphics_mesh=match mesh_data{
-		rbx_mesh::mesh_data::CSGPHS::CSGK(csgk)=>return Err(Error::NotSupposedToHappen),
+		rbx_mesh::mesh_data::CSGPHS::CSGK(_)=>return Err(Error::NotSupposedToHappen),
 		rbx_mesh::mesh_data::CSGPHS::CSGPHS2(mesh_data2)=>mesh_data2.mesh,
 		rbx_mesh::mesh_data::CSGPHS::CSGPHS4(mesh_data4)=>mesh_data4.mesh,
 	};
@@ -47,8 +47,7 @@ pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8])->Result<model::
 		// have not seen this format in practice
 		|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Block)
 		=>return Err(Error::NotSupposedToHappen),
-		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes3(meshes))
+		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes(meshes))
-		|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes5(meshes))
 		=>meshes.meshes,
 		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
 		=>vec![pim.mesh],