asd

lib/rbx_loader/src/primitives.rs

@@ -56,7 +56,7 @@ const CUBE_DEFAULT_TEXTURE_COORDS:[TextureCoordinate;4]=[
 	TextureCoordinate::new(1.0,1.0),
 	TextureCoordinate::new(0.0,1.0),
 ];
-const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
+pub const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
 	vec3::int(-1,-1, 1),//0 left bottom back
 	vec3::int( 1,-1, 1),//1 right bottom back
 	vec3::int( 1, 1, 1),//2 right top back
@@ -66,7 +66,7 @@ const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
 	vec3::int( 1,-1,-1),//6 right bottom front
 	vec3::int(-1,-1,-1),//7 left bottom front
 ];
-const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
+pub const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
 	vec3::int( 1, 0, 0),//CubeFace::Right
 	vec3::int( 0, 1, 0),//CubeFace::Top
 	vec3::int( 0, 0, 1),//CubeFace::Back
@@ -121,8 +121,7 @@ impl FaceDescription{
 		}
 	}
 }
-pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Mesh{
-	const CUBE_DEFAULT_POLYS:[[[u32;2];4];6]=[
+pub const CUBE_DEFAULT_POLYS:[[[u32;2];4];6]=[
 		// right (1, 0, 0)
 		[
 			[6,2],//[vertex,tex]
@@ -166,6 +165,7 @@ pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Me
 			[7,2],
 		],
 	];
+pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Mesh{
 	let mut generated_pos=Vec::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();

lib/rbx_loader/src/rbx.rs

@@ -763,6 +763,7 @@ impl PartialMap1<'_>{
 		meshpart_meshes.consume().map(|(old_mesh_id,mesh)|{
 			let mut aabb=strafesnet_common::aabb::Aabb::default();
 			for &pos in &mesh.unique_pos{
+				// the bug
 				aabb.grow(pos);
 			}
 			(old_mesh_id,MeshWithAabb{

lib/rbx_loader/src/union.rs

@@ -1,7 +1,10 @@
-use rbx_mesh::mesh_data::{NormalId2 as MeshDataNormalId2,VertexId as MeshDataVertexId};
+use crate::rbx::RobloxPartDescription;
+use crate::primitives::{CUBE_DEFAULT_VERTICES,CUBE_DEFAULT_POLYS};
+
+use rbx_mesh::mesh_data::{VertexId as MeshDataVertexId,NormalId2 as MeshDataNormalId2};
 use rbx_mesh::physics_data::VertexId as PhysicsDataVertexId;
 use strafesnet_common::model::{self,IndexedVertex,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId};
-use strafesnet_common::integer::vec3;
+use strafesnet_common::integer::{vec3,Planar64Vec3};
 
 #[allow(dead_code)]
 #[derive(Debug)]
@@ -57,10 +60,10 @@ pub fn convert(
 	roblox_physics_data:&[u8],
 	roblox_mesh_data:&[u8],
 	size:glam::Vec3,
-	crate::rbx::RobloxPartDescription(part_texture_description):crate::rbx::RobloxPartDescription,
+	RobloxPartDescription(part_texture_description):RobloxPartDescription,
 )->Result<model::Mesh,Error>{
 	const NORMAL_FACES:usize=6;
-	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
+	let mut polygon_groups_normal_id:[_;NORMAL_FACES]=[vec![],vec![],vec![],vec![],vec![],vec![]];
 
 	// build graphics and physics meshes
 	let mut mb=strafesnet_common::model::MeshBuilder::new();
@@ -126,7 +129,11 @@ pub fn convert(
 	};
 
 	//physics
-	let physics_convex_meshes=if !roblox_physics_data.is_empty(){
+	let polygon_groups_normal_it=polygon_groups_normal_id.into_iter().map(|faces|
+		// graphics polygon groups (to be rendered)
+		Ok(PolygonGroup::PolygonList(PolygonList::new(faces)))
+	);
+	let polygon_groups:Vec<PolygonGroup>=if !roblox_physics_data.is_empty(){
 		let physics_data=rbx_mesh::read_physics_data_versioned(
 			std::io::Cursor::new(roblox_physics_data)
 		).map_err(Error::RobloxPhysicsData)?;
@@ -140,33 +147,45 @@ pub fn convert(
 			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
 			=>vec![pim.mesh],
 		};
-		physics_convex_meshes
+		let physics_convex_meshes_it=physics_convex_meshes.into_iter().map(|mesh|{
+			// this can be factored out of the loop but I am lazy
+			let color=mb.acquire_color_id(glam::Vec4::ONE);
+			let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
+			// physics polygon groups (to do physics)
+			Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[PhysicsDataVertexId(vertex_id0),PhysicsDataVertexId(vertex_id1),PhysicsDataVertexId(vertex_id2)]|{
+				let face=[
+					mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
+					mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
+					mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
+				].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<_,_>>()?)))
+		});
+		polygon_groups_normal_it.chain(physics_convex_meshes_it).collect::<Result<_,_>>()?
 	}else{
-		Vec::new()
-	};
-	let polygon_groups:Vec<PolygonGroup>=polygon_groups_normal_id.into_iter().map(|faces|
-		// graphics polygon groups (to be rendered)
-		Ok(PolygonGroup::PolygonList(PolygonList::new(faces)))
-	).chain(physics_convex_meshes.into_iter().map(|mesh|{
-		// this can be factored out of the loop but I am lazy
-		let color=mb.acquire_color_id(glam::Vec4::ONE);
+		// generate a rectangular prism as default physics
+		let size=Planar64Vec3::new(size.to_array().map(|a|a.try_into().unwrap()));
+		let pos_list=CUBE_DEFAULT_VERTICES.map(|pos|
+			mb.acquire_pos_id(Planar64Vec3::new([
+				((pos.x*size.x)>>2).narrow_1().unwrap(),
+				((pos.y*size.y)>>2).narrow_1().unwrap(),
+				((pos.z*size.z)>>2).narrow_1().unwrap(),
+			]))
+		);
 		let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
-		// physics polygon groups (to do physics)
-		Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[PhysicsDataVertexId(vertex_id0),PhysicsDataVertexId(vertex_id1),PhysicsDataVertexId(vertex_id2)]|{
-			let face=[
-				mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
-				mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
-				mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
-			].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<_,_>>()?)))
-	})).collect::<Result<_,_>>()?;
+		let normal=mb.acquire_normal_id(vec3::ZERO);
+		let color=mb.acquire_color_id(glam::Vec4::ONE);
+		let polygon_group=PolygonGroup::PolygonList(PolygonList::new(CUBE_DEFAULT_POLYS.map(|poly|poly.map(|[pos_id,_]|
+			mb.acquire_vertex_id(IndexedVertex{pos:pos_list[pos_id as usize],tex,normal,color})
+		).to_vec()).to_vec()));
+		polygon_groups_normal_it.chain([Ok(polygon_group)]).collect::<Result<_,_>>()?
+	};
 	let physics_groups=(NORMAL_FACES..polygon_groups.len()).map(|id|model::IndexedPhysicsGroup{
 		groups:vec![PolygonGroupId::new(id as u32)]
 	}).collect();