divide physics_data by size instead of using sizeless transform

lib/rbx_loader/src/loader.rs

@@ -102,6 +102,7 @@ pub enum MeshType<'a>{
 	Union{
 		mesh_data:&'a [u8],
 		physics_data:&'a [u8],
+		size_float_bits:[u32;3],
 	},
 }
 #[derive(Hash,Eq,PartialEq)]
@@ -120,9 +121,14 @@ impl MeshIndex<'_>{
 		content:&'a str,
 		mesh_data:&'a [u8],
 		physics_data:&'a [u8],
+		size:&rbx_dom_weak::types::Vector3,
 	)->MeshIndex<'a>{
 		MeshIndex{
-			mesh_type:MeshType::Union{mesh_data,physics_data},
+			mesh_type:MeshType::Union{
+				mesh_data,
+				physics_data,
+				size_float_bits:[size.x.to_bits(),size.y.to_bits(),size.z.to_bits()]
+			},
 			content,
 		}
 	}
@@ -146,8 +152,9 @@ impl<'a> Loader for MeshLoader<'a>{
 				let data=read_entire_file(file_name)?;
 				crate::mesh::convert(RobloxMeshBytes::new(data))?
 			},
-			MeshType::Union{mut physics_data,mut mesh_data}=>{
+			MeshType::Union{mut physics_data,mut mesh_data,size_float_bits}=>{
 				// decode asset
+				let size=glam::Vec3::from_array(size_float_bits.map(f32::from_bits));
 				if !index.content.is_empty()&&(physics_data.is_empty()||mesh_data.is_empty()){
 					let RobloxAssetId(asset_id)=index.content.parse()?;
 					let file_name=format!("unions/{}",asset_id);
@@ -169,9 +176,9 @@ impl<'a> Loader for MeshLoader<'a>{
 							mesh_data=data.as_ref();
 						}
 					}
-					crate::union::convert(physics_data,mesh_data)?
+					crate::union::convert(physics_data,mesh_data,size)?
 				}else{
-					crate::union::convert(physics_data,mesh_data)?
+					crate::union::convert(physics_data,mesh_data,size)?
 				}
 			},
 		};

lib/rbx_loader/src/rbx.rs

@@ -554,7 +554,7 @@ pub fn convert<'a>(
 					object.properties.get("CanCollide"),
 				)
 			{
-				let mut model_transform=planar64_affine3_from_roblox(cf,size);
+				let model_transform=planar64_affine3_from_roblox(cf,size);
 
 				if model_transform.matrix3.det().is_zero(){
 					let mut parent_ref=object.parent();
@@ -716,9 +716,6 @@ pub fn convert<'a>(
 						panic!("Mesh has no Mesh or Texture");
 					},
 					Shape::PhysicsData=>{
-						//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 content="";
 						let mut mesh_data:&[u8]=&[];
 						let mut physics_data:&[u8]=&[];
@@ -732,7 +729,7 @@ pub fn convert<'a>(
 							physics_data=data.as_ref();
 						}
 						let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
-						let mesh_index=MeshIndex::union(content,mesh_data,physics_data);
+						let mesh_index=MeshIndex::union(content,mesh_data,physics_data,size);
 						let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
 						(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
 					},

lib/rbx_loader/src/union.rs

@@ -52,7 +52,7 @@ impl MeshDataNormalChecker{
 }
 
 impl std::error::Error for Error{}
-pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8])->Result<model::Mesh,Error>{
+pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8],size:glam::Vec3)->Result<model::Mesh,Error>{
 	const NORMAL_FACES:usize=6;
 	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
 
@@ -131,12 +131,12 @@ pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8])->Result<model::
 				mesh.vertices.get(vertex_id0.0 as usize).ok_or(Error::MissingVertexId(vertex_id0.0))?,
 				mesh.vertices.get(vertex_id1.0 as usize).ok_or(Error::MissingVertexId(vertex_id1.0))?,
 				mesh.vertices.get(vertex_id2.0 as usize).ok_or(Error::MissingVertexId(vertex_id2.0))?,
-			];
-			let vertex_norm=(glam::Vec3::from_slice(face[1])-glam::Vec3::from_slice(face[0]))
-			          .cross(glam::Vec3::from_slice(face[2])-glam::Vec3::from_slice(face[0])).to_array();
-			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex_norm).map_err(Error::Planar64Vec3)?);
-			face.into_iter().map(|&vertex_pos|{
-				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex_pos).map_err(Error::Planar64Vec3)?);
+			].map(|v|glam::Vec3::from_slice(v)/size);
+			let vertex_norm=(face[1]-face[0])
+			          .cross(face[2]-face[0]);
+			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex_norm.to_array()).map_err(Error::Planar64Vec3)?);
+			face.into_iter().map(|vertex_pos|{
+				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex_pos.to_array()).map_err(Error::Planar64Vec3)?);
 				Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
 			}).collect()
 		}).collect::<Result<_,_>>()?)))