idea: multiple collisions can happen in the same instant

The physics algorithm expects vertices to align exactly with faces.  Since the face normal is calculated via the cross product of vertex positions, this allows the face normals to be exact with respect to the vertex positions.

.gitignore

@@ -1 +1,2 @@
 /target
+.zed

Cargo.toml

@@ -24,7 +24,3 @@ resolver = "2"
 #lto = true
 strip = true
 codegen-units = 1
-
-[profile.dev]
-strip = false
-opt-level = 3

engine/graphics/Cargo.toml

@@ -11,4 +11,4 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "25.0.0"
+wgpu = "26.0.1"

engine/graphics/src/graphics.rs

@@ -953,6 +953,7 @@ impl GraphicsState{
 						}),
 						store:wgpu::StoreOp::Store,
 					},
+					depth_slice:None,
 				})],
 				depth_stencil_attachment:Some(wgpu::RenderPassDepthStencilAttachment{
 					view:&self.depth_view,

engine/physics/src/body.rs

@@ -18,6 +18,17 @@ impl<T> std::ops::Neg for Body<T>{
 		}
 	}
 }
+impl<T:Copy> std::ops::Neg for &Body<T>{
+	type Output=Body<T>;
+	fn neg(self)->Self::Output{
+		Body{
+			position:self.position,
+			velocity:-self.velocity,
+			acceleration:self.acceleration,
+			time:-self.time,
+		}
+	}
+}
 
 impl<T> Body<T>
 	where Time<T>:Copy,

engine/physics/src/face_crawler.rs

@@ -1,7 +1,9 @@
-use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
+use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
 use crate::physics::{Time,Body};
 
+use core::ops::Bound;
+
 enum Transition<M:MeshQuery>{
 	Miss,
 	Next(FEV<M>,GigaTime),
@@ -27,6 +29,47 @@ impl<M:MeshQuery> CrawlResult<M>{
 	}
 }
 
+// TODO: move predict_collision_face_out algorithm in here or something
+
+/// check_lower_bound
+pub fn low<LhsNum,LhsDen,RhsNum,RhsDen,T>(lower_bound:&Bound<Ratio<LhsNum,LhsDen>>,dt:&Ratio<RhsNum,RhsDen>)->bool
+where
+	RhsNum:Copy,
+	RhsDen:Copy,
+	LhsNum:Copy,
+	LhsDen:Copy,
+	LhsDen:strafesnet_common::integer::Parity,
+	RhsDen:strafesnet_common::integer::Parity,
+	LhsNum:core::ops::Mul<RhsDen,Output=T>,
+	LhsDen:core::ops::Mul<RhsNum,Output=T>,
+	T:Ord+Copy,
+{
+	match lower_bound{
+		Bound::Included(time)=>time.le_ratio(*dt),
+		Bound::Excluded(time)=>time.lt_ratio(*dt),
+		Bound::Unbounded=>true,
+	}
+}
+/// check_upper_bound
+pub fn upp<LhsNum,LhsDen,RhsNum,RhsDen,T>(dt:&Ratio<LhsNum,LhsDen>,upper_bound:&Bound<Ratio<RhsNum,RhsDen>>)->bool
+where
+	RhsNum:Copy,
+	RhsDen:Copy,
+	LhsNum:Copy,
+	LhsDen:Copy,
+	LhsDen:strafesnet_common::integer::Parity,
+	RhsDen:strafesnet_common::integer::Parity,
+	LhsNum:core::ops::Mul<RhsDen,Output=T>,
+	LhsDen:core::ops::Mul<RhsNum,Output=T>,
+	T:Ord+Copy,
+{
+	match upper_bound{
+		Bound::Included(time)=>dt.le_ratio(*time),
+		Bound::Excluded(time)=>dt.lt_ratio(*time),
+		Bound::Unbounded=>true,
+	}
+}
+
 impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
@@ -35,9 +78,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		M::Vert:Copy,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
-		<M as MeshQuery>::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
+		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition(&self,body_time:GigaTime,mesh:&M,body:&Body,mut best_time:GigaTime)->Transition<M>{
+	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -50,8 +93,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				//TODO: use higher precision d value?
 				//use the mesh transform translation instead of baking it into the d value.
 				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-						best_time=dt;
+					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						upper_bound=Bound::Included(dt);
 						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
@@ -65,8 +108,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//WARNING: precision is swept under the rug!
 					//wrap for speed
 					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							best_time=dt;
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
@@ -76,10 +119,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&FEV::Edge(edge_id)=>{
 				//test each face collision time, ignoring roots with zero or conflicting derivative
-				let edge_n=mesh.edge_n(edge_id);
 				let edge_verts=mesh.edge_verts(edge_id);
 				let &[ev0,ev1]=edge_verts.as_ref();
-				let delta_pos=body.position*2-(mesh.vert(ev0)+mesh.vert(ev1));
+				let (v0,v1)=(mesh.vert(ev0),mesh.vert(ev1));
+				let edge_n=v1-v0;
+				let delta_pos=body.position*2-(v0+v1);
 				for (i,&edge_face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=mesh.face_nd(edge_face_id).0;
 					//edge_n gets parity from the order of edge_faces
@@ -87,8 +131,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//WARNING yada yada d *2
 					//wrap for speed
 					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							best_time=dt;
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
 						}
@@ -99,9 +143,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
-							best_time=dt;
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
 							break;
 						}
@@ -115,9 +159,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					let n=-mesh.directed_edge_n(directed_edge_id);
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
-							best_time=dt;
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
@@ -128,19 +172,13 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		}
 		best_transition
 	}
-	pub fn crawl(mut self,mesh:&M,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<M>{
-		let mut body_time={
-			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num.widen_4(),r.den.widen_4())
-		};
-		let time_limit={
-			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.widen_4(),r.den.widen_4())
-		};
+	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
+		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
 		for _ in 0..20{
-			match self.next_transition(body_time,mesh,relative_body,time_limit){
+			match self.next_transition(mesh,relative_body,lower_bound,upper_bound){
 				Transition::Miss=>return CrawlResult::Miss(self),
-				Transition::Next(next_fev,next_time)=>(self,body_time)=(next_fev,next_time),
+				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
 			}
 		}

engine/physics/src/model.rs

@@ -1,5 +1,5 @@
 use std::collections::{HashSet,HashMap};
-use core::ops::Range;
+use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
@@ -68,11 +68,12 @@ pub enum FEV<M:MeshQuery>{
 }
 
 //use Unit32 #[repr(C)] for map files
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 struct Face{
 	normal:Planar64Vec3,
 	dot:Planar64,
 }
+#[derive(Debug)]
 struct Vert(Planar64Vec3);
 pub trait MeshQuery{
 	type Face:Copy;
@@ -97,18 +98,22 @@ pub trait MeshQuery{
 	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
 	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
 }
+#[derive(Debug)]
 struct FaceRefs{
 	edges:Vec<SubmeshDirectedEdgeId>,
 	//verts:Vec<VertId>,
 }
+#[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
 	verts:[SubmeshVertId;2],//bottom, top
 }
+#[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
+#[derive(Debug)]
 pub struct PhysicsMeshData{
 	//this contains all real and virtual faces used in both the complete mesh and convex submeshes
 	//faces are sorted such that all faces that belong to the complete mesh appear first, and then
@@ -118,6 +123,7 @@ pub struct PhysicsMeshData{
 	faces:Vec<Face>,//MeshFaceId indexes this list
 	verts:Vec<Vert>,//MeshVertId indexes this list
 }
+#[derive(Debug)]
 pub struct PhysicsMeshTopology{
 	//mapping of local ids to PhysicsMeshData ids
 	faces:Vec<MeshFaceId>,//SubmeshFaceId indexes this list
@@ -143,10 +149,12 @@ impl From<MeshId> for PhysicsMeshId{
 pub struct PhysicsSubmeshId(u32);
 pub struct PhysicsMesh{
 	data:PhysicsMeshData,
-	complete_mesh:PhysicsMeshTopology,
-	//Most objects in roblox maps are already convex, so the list length is 0
-	//as soon as the mesh is divided into 2 submeshes, the list length jumps to 2.
-	//length 1 is unnecessary since the complete mesh would be a duplicate of the only submesh, but would still function properly
+	// The complete mesh is unused at this time.
+	// complete_mesh:PhysicsMeshTopology,
+	// Submeshes are guaranteed to be convex and may contain
+	// "virtual" faces which are not part of the complete mesh.
+	// Physics calculations should never resolve to hitting
+	// a virtual face.
 	submeshes:Vec<PhysicsMeshTopology>,
 }
 impl PhysicsMesh{
@@ -210,19 +218,24 @@ impl PhysicsMesh{
 		};
 		Self{
 			data,
-			complete_mesh:mesh_topology,
-			submeshes:Vec::new(),
+			// complete_mesh:mesh_topology.clone(),
+			submeshes:vec![mesh_topology],
 		}
 	}
 	pub fn unit_cylinder()->Self{
 		Self::unit_cube()
 	}
 	#[inline]
-	pub const fn complete_mesh(&self)->&PhysicsMeshTopology{
-		&self.complete_mesh
+	pub fn complete_mesh(&self)->&PhysicsMeshTopology{
+		// If there is exactly one submesh, then the complete mesh is identical to it.
+		if self.submeshes.len()==1{
+			self.submeshes.first().unwrap()
+		}else{
+			panic!("PhysicsMesh complete mesh is not known");
+		}
 	}
 	#[inline]
-	pub const fn complete_mesh_view(&self)->PhysicsMeshView{
+	pub fn complete_mesh_view(&self)->PhysicsMeshView<'_>{
 		PhysicsMeshView{
 			data:&self.data,
 			topology:self.complete_mesh(),
@@ -230,21 +243,16 @@ impl PhysicsMesh{
 	}
 	#[inline]
 	pub fn submeshes(&self)->&[PhysicsMeshTopology]{
-		//the complete mesh is already a convex mesh when len()==0, len()==1 is invalid but will still work
-		if self.submeshes.len()==0{
-			std::slice::from_ref(&self.complete_mesh)
-		}else{
-			&self.submeshes.as_slice()
-		}
+		&self.submeshes
 	}
 	#[inline]
-	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView{
+	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView<'_>{
 		PhysicsMeshView{
 			data:&self.data,
 			topology:&self.submeshes()[submesh_id.get() as usize],
 		}
 	}
-	pub fn submesh_views(&self)->impl Iterator<Item=PhysicsMeshView>{
+	pub fn submesh_views(&self)->impl Iterator<Item=PhysicsMeshView<'_>>{
 		self.submeshes().iter().map(|topology|PhysicsMeshView{
 			data:&self.data,
 			topology,
@@ -313,14 +321,20 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 		if mesh.unique_pos.len()==0{
 			return Err(PhysicsMeshError::ZeroVertices);
 		}
+		// An empty physics mesh is a waste of resources
+		if mesh.physics_groups.len()==0{
+			return Err(PhysicsMeshError::NoPhysicsGroups);
+		}
 		let verts=mesh.unique_pos.iter().copied().map(Vert).collect();
 		//TODO: fix submeshes
 		//flat map mesh.physics_groups[$1].groups.polys()[$2] as face_id
 		//lower face_id points to upper face_id
 		//the same face is not allowed to be in multiple polygon groups
+		// because SubmeshFaceId -> CompleteMeshFaceId -> SubmeshFaceId is ambiguous
+		// when multiple SubmeshFaceId point to one MeshFaceId
 		let mut faces=Vec::new();
 		let mut face_id_from_face=HashMap::new();
-		let mut mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
+		let mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
 			//construct submesh
 			let mut submesh_faces=Vec::new();//these contain a map from submeshId->meshId
 			let mut submesh_verts=Vec::new();
@@ -381,15 +395,11 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 						normal:(normal/len as i64).divide().narrow_1().unwrap(),
 						dot:(dot/(len*len) as i64).narrow_1().unwrap(),
 					};
-					let face_id=match face_id_from_face.get(&face){
-						Some(&face_id)=>face_id,
-						None=>{
-							let face_id=MeshFaceId::new(faces.len() as u32);
-							face_id_from_face.insert(face.clone(),face_id);
-							faces.push(face);
-							face_id
-						}
-					};
+					let face_id=*face_id_from_face.entry(face).or_insert_with(||{
+						let face_id=MeshFaceId::new(faces.len() as u32);
+						faces.push(face);
+						face_id
+					});
 					submesh_faces.push(face_id);
 					face_ref_guys.push(FaceRefEdges(face_edges));
 				}
@@ -397,16 +407,16 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			PhysicsMeshTopology{
 				faces:submesh_faces,
 				verts:submesh_verts,
-				face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
-					FaceRefs{edges:face_ref_guy.0}
+				face_topology:face_ref_guys.into_iter().map(|FaceRefEdges(edges)|{
+					FaceRefs{edges}
 				}).collect(),
-				edge_topology:edge_pool.edge_guys.into_iter().map(|(edge_ref_verts,edge_ref_faces)|
-					EdgeRefs{faces:edge_ref_faces.0,verts:edge_ref_verts.0}
+				edge_topology:edge_pool.edge_guys.into_iter().map(|(EdgeRefVerts(verts),EdgeRefFaces(faces))|
+					EdgeRefs{faces,verts}
 				).collect(),
-				vert_topology:vert_ref_guys.into_iter().map(|vert_ref_guy|
+				vert_topology:vert_ref_guys.into_iter().map(|VertRefGuy{edges,faces}|
 					VertRefs{
-						edges:vert_ref_guy.edges.into_iter().collect(),
-						faces:vert_ref_guy.faces.into_iter().collect(),
+						edges:edges.into_iter().collect(),
+						faces:faces.into_iter().collect(),
 					}
 				).collect(),
 			}
@@ -416,12 +426,13 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 				faces,
 				verts,
 			},
-			complete_mesh:mesh_topologies.pop().ok_or(PhysicsMeshError::NoPhysicsGroups)?,
+			// complete_mesh:None,
 			submeshes:mesh_topologies,
 		})
 	}
 }
 
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -458,6 +469,7 @@ impl MeshQuery for PhysicsMeshView<'_>{
 	}
 }
 
+#[derive(Debug)]
 pub struct PhysicsMeshTransform{
 	pub vertex:integer::Planar64Affine3,
 	pub normal:integer::mat3::Matrix3<Fixed<2,64>>,
@@ -473,6 +485,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -490,9 +503,6 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
-	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
-		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
-	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
@@ -598,6 +608,7 @@ pub enum MinkowskiFace{
 	//FaceFace
 }
 
+#[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
 	mesh0:TransformedMesh<'a>,
 	mesh1:TransformedMesh<'a>,
@@ -615,6 +626,10 @@ enum EV{
 }
 
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
+pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
+	let r=(time-relative_to).to_ratio();
+	Ratio::new(r.num.widen_4(),r.den.widen_4())
+}
 
 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
@@ -685,7 +700,7 @@ impl MinkowskiMesh<'_>{
 		}
 	}
 	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh>{
+	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh<'_>>{
 		//start on any vertex
 		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 		//cross edge-face boundary if it's uncrossable
@@ -730,44 +745,44 @@ impl MinkowskiMesh<'_>{
 	//
 	// Most of the calculation time is just calculating the starting point
 	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Time)->Option<FEV<MinkowskiMesh>>{
+	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh<'_>>>{
 		infinity_body.infinity_dir().and_then(|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			// TODO: change crawl_fev args to delta time? Optional values?
-			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
+			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
 			//continue forwards along the body parabola
-			fev.crawl(self,relative_body,start_time,time_limit).hit()
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		//create an extrapolated body at time_limit
-		let infinity_body=-relative_body.clone();
-		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|fev|{
+	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// swap and negate bounds to do a time inversion
+		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
+		let infinity_body=-relative_body;
+		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
 			//continue backwards along the body parabola
-			fev.crawl(self,&infinity_body,-time_limit,-start_time).hit()
+			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
 				//no need to test -time<time_limit because of the first step
 				.map(|(face,time)|(face,-time))
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+		// TODO: make better
+		use crate::face_crawler::{low,upp};
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
-		let start_time={
-			let r=(start_time-relative_body.time).to_ratio();
+		let start_time=range.start_bound().map(|&t|{
+			let r=(t-relative_body.time).to_ratio();
 			Ratio::new(r.num,r.den)
-		};
-		let mut best_time={
-			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.widen_4(),r.den.widen_4())
-		};
+		});
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
 		let mut best_edge=None;
 		let face_n=self.face_nd(contact_face_id).0;
 		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
@@ -780,18 +795,19 @@ impl MinkowskiMesh<'_>{
 			//WARNING: truncated precision
 			//wrap for speed
 			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
-				if start_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=dt;
-					best_edge=Some(directed_edge_id);
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					best_time=Bound::Included(dt);
+					best_edge=Some((directed_edge_id,dt));
 					break;
 				}
 			}
 		}
-		best_edge.map(|e|(e.as_undirected(),best_time))
+		best_edge
 	}
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time).hit()
+		// Bound::Included means that the surface of the mesh is included in the mesh
+		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
 		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
@@ -929,10 +945,10 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
 		AsRefHelper(match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>(*self.mesh1.edge_verts(e1).as_ref()).map(|vert_id1|
+			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
 				MinkowskiVert::VertVert(v0,vert_id1)
 			),
-			MinkowskiEdge::EdgeVert(e0,v1)=>(*self.mesh0.edge_verts(e0).as_ref()).map(|vert_id0|
+			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
 				MinkowskiVert::VertVert(vert_id0,v1)
 			),
 		})
@@ -942,38 +958,43 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			MinkowskiVert::VertVert(v0,v1)=>{
 				let mut edges=Vec::new();
 				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f=self.mesh0.vert_faces(v0);
-				let v1f=self.mesh1.vert_faces(v1);
-				let v0f_n:Vec<_>=v0f.as_ref().iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.as_ref().iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				let the_len=v0f.as_ref().len()+v1f.as_ref().len();
+				let v0f_thing=self.mesh0.vert_faces(v0);
+				let v1f_thing=self.mesh1.vert_faces(v1);
+				let v0f=v0f_thing.as_ref();
+				let v1f=v1f_thing.as_ref();
+				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				// scratch vector
+				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
+				face_normals.clone_from(&v0f_n);
 				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
 					let n=self.mesh0.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
 					// TODO: there's gotta be a better way to do this
-					//make a set of faces
-					let mut face_normals=Vec::with_capacity(the_len);
-					//add mesh0 faces as-is
-					face_normals.clone_from(&v0f_n);
+					// drop faces beyond v0f_n
+					face_normals.truncate(v0f.len());
+					// make a set of faces from mesh0's perspective
 					for face_n in &v1f_n{
 						//add reflected mesh1 faces
 						//wrap for speed
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
-					if is_empty_volume(face_normals){
+					if is_empty_volume(&face_normals){
 						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
 					}
 				}
+				face_normals.clone_from(&v1f_n);
 				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
 					let n=self.mesh1.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
-					let mut face_normals=Vec::with_capacity(the_len);
-					face_normals.clone_from(&v1f_n);
+					// drop faces beyond v1f_n
+					face_normals.truncate(v1f.len());
+					// make a set of faces from mesh1's perspective
 					for face_n in &v0f_n{
 						//wrap for speed
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
-					if is_empty_volume(face_normals){
+					if is_empty_volume(&face_normals){
 						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
 					}
 				}
@@ -983,11 +1004,12 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
 		unimplemented!();
-		vec![]
+		#[expect(unreachable_code)]
+		Vec::new()
 	}
 }
 
-fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
+fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
 	let len=normals.len();
 	for i in 0..len-1{
 		for j in i+1..len{
@@ -1013,6 +1035,6 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 
 #[test]
 fn test_is_empty_volume(){
-	assert!(!is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()].to_vec()));
-	assert!(is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()].to_vec()));
+	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
+	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
 }

engine/physics/src/physics.rs

@@ -25,8 +25,13 @@ use strafesnet_common::physics::{Instruction,MouseInstruction,ModeInstruction,Mi
 //when the physics asks itself what happens next, this is how it's represented
 #[derive(Debug)]
 pub enum InternalInstruction{
-	CollisionStart(Collision,model_physics::GigaTime),
-	CollisionEnd(Collision,model_physics::GigaTime),
+	// begin accepting touch updates
+	OpenMultiCollision(model_physics::GigaTime),
+	// mutliple touch updates
+	CollisionStart(Collision),
+	CollisionEnd(Collision),
+	// confirm there will be no more touch updates and apply the transaction
+	CloseMultiCollision,
 	StrafeTick,
 	ReachWalkTargetVelocity,
 	// Water,
@@ -100,6 +105,7 @@ enum TransientAcceleration{
 		time:Time,
 	},
 	//walk target will never be reached
+	#[expect(dead_code)]
 	Unreachable{
 		acceleration:Planar64Vec3,
 	}
@@ -184,6 +190,7 @@ struct PhysicsModels{
 	intersect_attributes:HashMap<IntersectAttributesId,gameplay_attributes::IntersectAttributes>,
 }
 impl PhysicsModels{
+	#[expect(dead_code)]
 	fn clear(&mut self){
 		self.meshes.clear();
 		self.contact_models.clear();
@@ -191,7 +198,7 @@ impl PhysicsModels{
 		self.contact_attributes.clear();
 		self.intersect_attributes.clear();
 	}
-	fn mesh(&self,convex_mesh_id:ConvexMeshId)->TransformedMesh{
+	fn mesh(&self,convex_mesh_id:ConvexMeshId)->TransformedMesh<'_>{
 		let (mesh_id,transform)=match convex_mesh_id.model_id{
 			PhysicsModelId::Contact(model_id)=>{
 				let model=&self.contact_models[&model_id];
@@ -208,14 +215,14 @@ impl PhysicsModels{
 		)
 	}
 	//it's a bit weird to have three functions, but it's always going to be one of these
-	fn contact_mesh(&self,contact:&ContactCollision)->TransformedMesh{
+	fn contact_mesh(&self,contact:&ContactCollision)->TransformedMesh<'_>{
 		let model=&self.contact_models[&contact.model_id];
 		TransformedMesh::new(
 			self.meshes[&model.mesh_id].submesh_view(contact.submesh_id),
 			&model.transform
 		)
 	}
-	fn intersect_mesh(&self,intersect:&IntersectCollision)->TransformedMesh{
+	fn intersect_mesh(&self,intersect:&IntersectCollision)->TransformedMesh<'_>{
 		let model=&self.intersect_models[&intersect.model_id];
 		TransformedMesh::new(
 			self.meshes[&model.mesh_id].submesh_view(intersect.submesh_id),
@@ -284,6 +291,7 @@ impl PhysicsCamera{
 	fn rotation(&self)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos)
 	}
+	#[expect(dead_code)]
 	fn simulate_move_rotation(&self,mouse_delta:glam::IVec2)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos+mouse_delta)
 	}
@@ -351,6 +359,7 @@ mod gameplay{
 		pub fn unordered_checkpoint_count(&self)->u32{
 			self.unordered_checkpoints.len() as u32
 		}
+		#[expect(dead_code)]
 		pub fn set_mode_id(&mut self,mode_id:gameplay_modes::ModeId){
 			self.clear();
 			self.mode_id=mode_id;
@@ -417,7 +426,7 @@ impl HitboxMesh{
 		}
 	}
 	#[inline]
-	const fn transformed_mesh(&self)->TransformedMesh{
+	fn transformed_mesh(&self)->TransformedMesh<'_>{
 		TransformedMesh::new(self.mesh.complete_mesh_view(),&self.transform)
 	}
 }
@@ -485,6 +494,7 @@ enum MoveState{
 	Air,
 	Walk(ContactMoveState),
 	Ladder(ContactMoveState),
+	#[expect(dead_code)]
 	Water,
 	Fly,
 }
@@ -863,6 +873,15 @@ impl Default for PhysicsState{
 }
 
 impl PhysicsState{
+	pub fn new_with_body(body:Body)->Self{
+		Self{
+			body,
+			..Self::default()
+		}
+	}
+	pub const fn body(&self)->&Body{
+		&self.body
+	}
 	pub fn camera_body(&self)->Body{
 		Body{
 			position:self.body.position+self.style.camera_offset,
@@ -938,8 +957,8 @@ pub struct PhysicsData{
 	//cached calculations
 	hitbox_mesh:HitboxMesh,
 }
-impl Default for PhysicsData{
-	fn default()->Self{
+impl PhysicsData{
+	pub fn empty()->Self{
  		Self{
 			bvh:bvh::BvhNode::empty(),
 			models:Default::default(),
@@ -947,47 +966,7 @@ impl Default for PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
-}
-// the collection of information required to run physics
-pub struct PhysicsContext<'a>{
-	state:&'a mut PhysicsState,//this captures the entire state of the physics.
-	data:&'a PhysicsData,//data currently loaded into memory which is needded for physics to run, but is not part of the state.
-}
-// the physics consumes both Instruction and PhysicsInternalInstruction,
-// but can only emit PhysicsInternalInstruction
-impl InstructionConsumer<InternalInstruction> for PhysicsContext<'_>{
-	type Time=Time;
-	fn process_instruction(&mut self,ins:TimedInstruction<InternalInstruction,Time>){
-		atomic_internal_instruction(&mut self.state,&self.data,ins)
-	}
-}
-impl InstructionConsumer<Instruction> for PhysicsContext<'_>{
-	type Time=Time;
-	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Time>){
-		atomic_input_instruction(&mut self.state,&self.data,ins)
-	}
-}
-impl InstructionEmitter<InternalInstruction> for PhysicsContext<'_>{
-	type Time=Time;
-	//this little next instruction function could cache its return value and invalidate the cached value by watching the State.
-	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
-		next_instruction_internal(&self.state,&self.data,time_limit)
-	}
-}
-impl PhysicsContext<'_>{
-	pub fn run_input_instruction(
-		state:&mut PhysicsState,
-		data:&PhysicsData,
-		instruction:TimedInstruction<Instruction,Time>
-	){
-		let mut context=PhysicsContext{state,data};
-		context.process_exhaustive(instruction.time);
-		context.process_instruction(instruction);
-	}
-}
-impl PhysicsData{
-	/// use with caution, this is the only non-instruction way to mess with physics
-	pub fn generate_models(&mut self,map:&map::CompleteMap){
+	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
@@ -1114,11 +1093,50 @@ impl PhysicsData{
 					(IntersectAttributesId::new(attr_id as u32),attr)
 				).collect(),
 		};
-		self.bvh=bvh;
-		self.models=models;
-		self.modes=modes;
-		//hitbox_mesh is unchanged
 		println!("Physics Objects: {}",model_count);
+		Self{
+			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
+			bvh,
+			models,
+			modes,
+		}
+	}
+}
+// the collection of information required to run physics
+pub struct PhysicsContext<'a>{
+	state:&'a mut PhysicsState,//this captures the entire state of the physics.
+	data:&'a PhysicsData,//data currently loaded into memory which is needded for physics to run, but is not part of the state.
+}
+// the physics consumes both Instruction and PhysicsInternalInstruction,
+// but can only emit PhysicsInternalInstruction
+impl InstructionConsumer<InternalInstruction> for PhysicsContext<'_>{
+	type Time=Time;
+	fn process_instruction(&mut self,ins:TimedInstruction<InternalInstruction,Time>){
+		atomic_internal_instruction(&mut self.state,&self.data,ins)
+	}
+}
+impl InstructionConsumer<Instruction> for PhysicsContext<'_>{
+	type Time=Time;
+	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Time>){
+		atomic_input_instruction(&mut self.state,&self.data,ins)
+	}
+}
+impl InstructionEmitter<InternalInstruction> for PhysicsContext<'_>{
+	type Time=Time;
+	//this little next instruction function could cache its return value and invalidate the cached value by watching the State.
+	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
+		next_instruction_internal(&self.state,&self.data,time_limit)
+	}
+}
+impl PhysicsContext<'_>{
+	pub fn run_input_instruction(
+		state:&mut PhysicsState,
+		data:&PhysicsData,
+		instruction:TimedInstruction<Instruction,Time>
+	){
+		let mut context=PhysicsContext{state,data};
+		context.process_exhaustive(instruction.time);
+		context.process_instruction(instruction);
 	}
 }
 
@@ -1193,7 +1211,7 @@ fn recalculate_touching(
 		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(contact.model_id),contact)
 	}
 	while let Some(&intersect)=touching.intersects.iter().next(){
-		collision_end_intersect(touching,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
+		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
 	}
 	//find all models in the teleport region
 	let mut aabb=aabb::Aabb::default();
@@ -1264,6 +1282,7 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3){
 	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);
 }
+#[expect(dead_code)]
 fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
@@ -1605,6 +1624,7 @@ fn collision_start_intersect(
 			None=>(),
 		}
 	}
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	run_teleport_behaviour(intersect.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
 }
 
@@ -1637,7 +1657,14 @@ fn collision_end_contact(
 	}
 }
 fn collision_end_intersect(
+	move_state:&mut MoveState,
+	body:&mut Body,
 	touching:&mut TouchingState,
+	models:&PhysicsModels,
+	hitbox_mesh:&HitboxMesh,
+	style:&StyleModifiers,
+	camera:&PhysicsCamera,
+	input_state:&InputState,
 	mode:Option<&gameplay_modes::Mode>,
 	run:&mut run::Run,
 	_attr:&gameplay_attributes::IntersectAttributes,
@@ -1645,6 +1672,7 @@ fn collision_end_intersect(
 	time:Time,
 ){
 	touching.remove(&Collision::Intersect(intersect));
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(intersect.model_id.into());
 		match zone{
@@ -1701,7 +1729,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					contact
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
-					&mut state.touching,
+					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.modes.get_mode(state.mode_state.get_mode_id()),
 					&mut state.run,
 					data.models.intersect_attr(intersect.model_id),
@@ -1911,7 +1939,7 @@ mod test{
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
-		test_collision_axis_aligned(relative_body.clone(),expected_collision_time);
+		test_collision_axis_aligned(relative_body,expected_collision_time);
 		test_collision_rotated(relative_body,expected_collision_time);
 	}
 	#[test]
@@ -1924,6 +1952,15 @@ mod test{
 		),Some(Time::from_secs(2)));
 	}
 	#[test]
+	fn test_collision_small_mv(){
+		test_collision(Body::new(
+			int3(0,5,0),
+			int3(0,-1,0)+(vec3::X>>32),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)));
+	}
+	#[test]
 	fn test_collision_degenerate_east(){
 		test_collision(Body::new(
 			int3(3,5,0),
@@ -2094,4 +2131,115 @@ mod test{
 			Time::ZERO
 		),None);
 	}
+	// overlap edges by 1 epsilon
+	#[test]
+	fn almost_miss_north(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,-7)>>1)+vec3::raw_xyz(0,0,1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	#[test]
+	fn almost_miss_east(){
+		test_collision_axis_aligned(Body::new(
+			(int3(7,10,0)>>1)+vec3::raw_xyz(-1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	#[test]
+	fn almost_miss_south(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,7)>>1)+vec3::raw_xyz(0,0,-1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	#[test]
+	fn almost_miss_west(){
+		test_collision_axis_aligned(Body::new(
+			(int3(-7,10,0)>>1)+vec3::raw_xyz(1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	// exactly miss edges
+	#[test]
+	fn exact_miss_north(){
+		test_collision_axis_aligned(Body::new(
+			int3(0,10,-7)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn exact_miss_east(){
+		test_collision_axis_aligned(Body::new(
+			int3(7,10,0)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn exact_miss_south(){
+		test_collision_axis_aligned(Body::new(
+			int3(0,10,7)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn exact_miss_west(){
+		test_collision_axis_aligned(Body::new(
+			int3(-7,10,0)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	// miss edges by 1 epsilon
+	#[test]
+	fn narrow_miss_north(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,-7)>>1)-vec3::raw_xyz(0,0,1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn narrow_miss_east(){
+		test_collision_axis_aligned(Body::new(
+			(int3(7,10,0)>>1)-vec3::raw_xyz(-1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn narrow_miss_south(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,7)>>1)-vec3::raw_xyz(0,0,-1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn narrow_miss_west(){
+		test_collision_axis_aligned(Body::new(
+			(int3(-7,10,0)>>1)-vec3::raw_xyz(1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
 }

engine/physics/src/push_solve.rs

@@ -192,7 +192,7 @@ fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Optio
 const fn get_best_push_ray_and_conts_0<'a>(point:Planar64Vec3)->(Ray,Conts<'a>){
 	(get_push_ray_0(point),Conts::new_const())
 }
-fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts)>{
+fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts<'_>)>{
 	get_push_ray_1(point,c0)
 		.map(|ray|(ray,Conts::from_iter([c0])))
 }

engine/session/src/session.rs

@@ -172,7 +172,7 @@ impl Session{
 			user_settings,
 			directories,
 			mouse_interpolator:MouseInterpolator::new(),
-			geometry_shared:Default::default(),
+			geometry_shared:PhysicsData::empty(),
 			simulation,
 			view_state:ViewState::Play,
 			recording:Default::default(),
@@ -184,7 +184,7 @@ impl Session{
 	}
 	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
 		self.simulation.physics.clear();
-		self.geometry_shared.generate_models(map);
+		self.geometry_shared=PhysicsData::new(map);
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{

integration-testing/.gitignore

@@ -0,0 +1 @@
+/test_files

integration-testing/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+glam = "0.30.0"
 strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }
+# this is just for the primitive constructor
+strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }

integration-testing/src/error.rs

@@ -0,0 +1,28 @@
+#[expect(dead_code)]
+#[derive(Debug)]
+pub enum ReplayError{
+	IO(std::io::Error),
+	SNF(strafesnet_snf::Error),
+	SNFM(strafesnet_snf::map::Error),
+	SNFB(strafesnet_snf::bot::Error),
+}
+impl From<std::io::Error> for ReplayError{
+	fn from(value:std::io::Error)->Self{
+		Self::IO(value)
+	}
+}
+impl From<strafesnet_snf::Error> for ReplayError{
+	fn from(value:strafesnet_snf::Error)->Self{
+		Self::SNF(value)
+	}
+}
+impl From<strafesnet_snf::map::Error> for ReplayError{
+	fn from(value:strafesnet_snf::map::Error)->Self{
+		Self::SNFM(value)
+	}
+}
+impl From<strafesnet_snf::bot::Error> for ReplayError{
+	fn from(value:strafesnet_snf::bot::Error)->Self{
+		Self::SNFB(value)
+	}
+}

integration-testing/src/main.rs

@@ -1,7 +1,15 @@
-use std::io::Cursor;
-use std::path::Path;
+mod error;
+mod util;
+
+#[cfg(test)]
+mod tests;
+#[cfg(test)]
+mod test_scenes;
+
 use std::time::Instant;
 
+use error::ReplayError;
+use util::read_entire_file;
 use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
 
 fn main(){
@@ -13,40 +21,6 @@ fn main(){
 	}
 }
 
-#[allow(unused)]
-#[derive(Debug)]
-enum ReplayError{
-	IO(std::io::Error),
-	SNF(strafesnet_snf::Error),
-	SNFM(strafesnet_snf::map::Error),
-	SNFB(strafesnet_snf::bot::Error),
-}
-impl From<std::io::Error> for ReplayError{
-	fn from(value:std::io::Error)->Self{
-		Self::IO(value)
-	}
-}
-impl From<strafesnet_snf::Error> for ReplayError{
-	fn from(value:strafesnet_snf::Error)->Self{
-		Self::SNF(value)
-	}
-}
-impl From<strafesnet_snf::map::Error> for ReplayError{
-	fn from(value:strafesnet_snf::map::Error)->Self{
-		Self::SNFM(value)
-	}
-}
-impl From<strafesnet_snf::bot::Error> for ReplayError{
-	fn from(value:strafesnet_snf::bot::Error)->Self{
-		Self::SNFB(value)
-	}
-}
-
-fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let data=std::fs::read(path)?;
-	Ok(Cursor::new(data))
-}
-
 fn run_replay()->Result<(),ReplayError>{
 	println!("loading map file..");
 	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
@@ -57,9 +31,8 @@ fn run_replay()->Result<(),ReplayError>{
 	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
 
 	// create recording
-	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	physics_data.generate_models(&map);
+	let physics_data=PhysicsData::new(&map);
 	println!("simulating...");
 	let mut physics=PhysicsState::default();
 	for ins in bot.instructions{
@@ -167,9 +140,8 @@ fn test_determinism()->Result<(),ReplayError>{
 	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
 	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
 
-	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	physics_data.generate_models(&map);
+	let physics_data=PhysicsData::new(&map);
 
 	let (send,recv)=std::sync::mpsc::channel();
 

integration-testing/src/test_scenes.rs

@@ -0,0 +1,91 @@
+use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
+use strafesnet_common::gameplay_modes::NormalizedModes;
+use strafesnet_common::gameplay_attributes::{CollisionAttributes,CollisionAttributesId};
+use strafesnet_common::integer::{vec3,mat3,Planar64Affine3,Time};
+use strafesnet_common::model::{Mesh,Model,MeshId,ModelId,RenderConfigId};
+use strafesnet_common::map::CompleteMap;
+use strafesnet_common::physics::Instruction;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_rbx_loader::primitives::{unit_cube,CubeFaceDescription};
+
+struct TestSceneBuilder{
+	meshes:Vec<Mesh>,
+	models:Vec<Model>,
+}
+impl TestSceneBuilder{
+	fn new()->Self{
+		Self{
+			meshes:Vec::new(),
+			models:Vec::new(),
+		}
+	}
+	fn push_mesh(&mut self,mesh:Mesh)->MeshId{
+		let mesh_id=self.meshes.len();
+		self.meshes.push(mesh);
+		MeshId::new(mesh_id as u32)
+	}
+	fn push_mesh_instance(&mut self,mesh:MeshId,transform:Planar64Affine3)->ModelId{
+		let model=Model{
+			mesh,
+			attributes:CollisionAttributesId::new(0),
+			color:glam::Vec4::ONE,
+			transform,
+		};
+		let model_id=self.models.len();
+		self.models.push(model);
+		ModelId::new(model_id as u32)
+	}
+	fn build(self)->PhysicsData{
+		let modes=NormalizedModes::new(Vec::new());
+		let attributes=vec![CollisionAttributes::contact_default()];
+		let meshes=self.meshes;
+		let models=self.models;
+		let textures=Vec::new();
+		let render_configs=Vec::new();
+		PhysicsData::new(&CompleteMap{
+			modes,
+			attributes,
+			meshes,
+			models,
+			textures,
+			render_configs,
+		})
+	}
+}
+
+fn test_scene()->PhysicsData{
+	let mut builder=TestSceneBuilder::new();
+	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
+	let mesh=builder.push_mesh(unit_cube(cube_face_description));
+	// place two 5x5x5 cubes.
+	builder.push_mesh_instance(mesh,Planar64Affine3::new(
+		mat3::from_diagonal(vec3::int(5,5,5)>>1),
+		vec3::int(0,0,0)
+	));
+	builder.push_mesh_instance(mesh,Planar64Affine3::new(
+		mat3::from_diagonal(vec3::int(5,5,5)>>1),
+		vec3::int(5,-5,0)
+	));
+	builder.build()
+}
+
+#[test]
+fn simultaneous_collision(){
+	let physics_data=test_scene();
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::int(5+1,1,0),
+		vec3::int(-1,-1,0),
+		vec3::int(0,0,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,TimedInstruction{
+		time:Time::from_secs(2),
+		instruction:Instruction::Idle,
+	});
+	let body=physics.body();
+	assert_eq!(body.position,vec3::int(5,0,0));
+	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
+	assert_eq!(body.time,Time::ONE_SECOND);
+}

integration-testing/src/tests.rs

@@ -0,0 +1,76 @@
+use crate::error::ReplayError;
+use crate::util::read_entire_file;
+use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
+
+#[test]
+#[ignore]
+fn physics_bug_2()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("test_files/bhop_monster_jam.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	println!("generating models..");
+	let physics_data=PhysicsData::new(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	// body pos = Vector { array: [Fixed { bits: 554895163352 }, Fixed { bits: 1485633089990 }, Fixed { bits: 1279601007173 }] }
+	// after the fix it's still happening, possibly for a different reason, new position to evince:
+	// body pos = Vector { array: [Fixed { bits: 555690659654 }, Fixed { bits: 1490485868773 }, Fixed { bits: 1277783839382 }] }
+	use strafesnet_common::integer::{vec3,Time};
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::raw_xyz(555690659654,1490485868773,1277783839382),
+		vec3::int(0,0,0),
+		vec3::int(0,-100,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	// wait one second to activate the bug
+	// hit=Some(ModelId(2262))
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
+}
+
+#[test]
+#[ignore]
+fn physics_bug_3()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("../tools/bhop_maps/5692152916.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	println!("generating models..");
+	let physics_data=PhysicsData::new(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	use strafesnet_common::integer::{vec3,Time};
+	let body=strafesnet_physics::physics::Body::new(
+		// bhop_toc corner position after wall hits
+		// vec3::raw_xyz(-1401734815424,3315081280280,-2466057177493),
+		// vec3::raw_xyz(0,-96915585363,1265),
+		// vec3::raw_xyz(0,-429496729600,0),
+		// alternate room center position
+		// vec3::raw_xyz(-1129043783837,3324870327882,-2014012350212),
+		// vec3::raw_xyz(0,-96915585363,1265),
+		// vec3::raw_xyz(0,-429496729600,0),
+		// corner setup before wall hits
+		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
+		vec3::raw_xyz(0,-429496729600,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	// wait one second to activate the bug
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
+}

integration-testing/src/util.rs

@@ -0,0 +1,7 @@
+use std::io::Cursor;
+use std::path::Path;
+
+pub fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
+	let data=std::fs::read(path)?;
+	Ok(Cursor::new(data))
+}

lib/bsp_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_bsp_loader"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -11,8 +11,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 glam = "0.30.0"
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.0", path = "../deferred_loader", registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
 vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"

lib/bsp_loader/src/brush.rs

@@ -187,7 +187,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 	}
 }
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Debug)]
 pub enum BrushToMeshError{
 	SliceBrushSides,

lib/bsp_loader/src/bsp.rs

@@ -349,7 +349,7 @@ pub struct PartialMap1{
 impl PartialMap1{
 	pub fn add_prop_meshes<'a>(
 		self,
-		prop_meshes:Meshes,
+		prop_meshes:Meshes<model::Mesh>,
 	)->PartialMap2{
 		PartialMap2{
 			attributes:self.attributes,

lib/bsp_loader/src/loader.rs

@@ -5,7 +5,6 @@ use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
 
 use crate::{Bsp,Vpk};
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum TextureError{
 	Io(std::io::Error),
@@ -41,7 +40,6 @@ impl Loader for TextureLoader{
 	}
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum MeshError{
 	Io(std::io::Error),

lib/common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_common"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"

lib/common/src/aabb.rs

@@ -2,7 +2,9 @@ use crate::integer::{vec3,Planar64Vec3};
 
 #[derive(Clone)]
 pub struct Aabb{
+	// min is inclusive
 	min:Planar64Vec3,
+	// max is not inclusive
 	max:Planar64Vec3,
 }
 
@@ -43,7 +45,7 @@ impl Aabb{
 	}
 	#[inline]
 	pub fn contains(&self,point:Planar64Vec3)->bool{
-		let bvec=self.min.lt(point)&point.lt(self.max);
+		let bvec=self.min.le(point)&point.lt(self.max);
 		bvec.all()
 	}
 	#[inline]

lib/common/src/gameplay_modes.rs

@@ -140,6 +140,15 @@ impl ModeId{
 	pub const MAIN:Self=Self(0);
 	pub const BONUS:Self=Self(1);
 }
+impl core::fmt::Display for ModeId{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->core::fmt::Result{
+		match self{
+			&Self::MAIN=>write!(f,"Main"),
+			&Self::BONUS=>write!(f,"Bonus"),
+			&Self(mode_id)=>write!(f,"Bonus{mode_id}"),
+		}
+	}
+}
 #[derive(Clone)]
 pub struct Mode{
 	style:gameplay_style::StyleModifiers,

lib/common/src/integer.rs

@@ -1,5 +1,5 @@
 pub use fixed_wide::fixed::*;
-pub use ratio_ops::ratio::{Ratio,Divide};
+pub use ratio_ops::ratio::{Ratio,Divide,Parity};
 
 //integer units
 
@@ -132,20 +132,21 @@ impl<T> std::ops::Mul for Time<T>{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
 	}
 }
-impl<T> std::ops::Div<i64> for Time<T>{
-	type Output=Self;
-	#[inline]
-	fn div(self,rhs:i64)->Self::Output{
-		Self::raw(self.0/rhs)
-	}
-}
-impl<T> std::ops::Mul<i64> for Time<T>{
-	type Output=Self;
-	#[inline]
-	fn mul(self,rhs:i64)->Self::Output{
-		Self::raw(self.0*rhs)
+macro_rules! impl_time_i64_rhs_operator {
+	($op:ident,$method:ident)=>{
+		impl<T> core::ops::$op<i64> for Time<T>{
+			type Output=Self;
+			#[inline]
+			fn $method(self,rhs:i64)->Self::Output{
+				Self::raw(self.0.$method(rhs))
+			}
+		}
 	}
 }
+impl_time_i64_rhs_operator!(Div,div);
+impl_time_i64_rhs_operator!(Mul,mul);
+impl_time_i64_rhs_operator!(Shr,shr);
+impl_time_i64_rhs_operator!(Shl,shl);
 impl<T> core::ops::Mul<Time<T>> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
 	fn mul(self,rhs:Time<T>)->Self::Output{
@@ -656,7 +657,7 @@ pub mod mat3{
 	}
 }
 
-#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Default,Hash,Eq,PartialEq)]
 pub struct Planar64Affine3{
 	pub matrix3:Planar64Mat3,//includes scale above 1
 	pub translation:Planar64Vec3,

lib/common/src/model.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::integer::{Planar64Vec3,Planar64Affine3};
+use crate::integer::{Planar64,Planar64Vec3,Planar64Affine3};
 use crate::gameplay_attributes;
 
 pub type TextureCoordinate=glam::Vec2;
@@ -168,6 +168,11 @@ impl MeshBuilder{
 		}
 	}
 	pub fn acquire_pos_id(&mut self,pos:Planar64Vec3)->PositionId{
+		// Truncate the 16 most precise bits of the vertex positions.
+		// This allows the normal vectors to exactly represent the face.
+		// Remove this in Mesh V2
+		const MASK:Planar64=Planar64::raw(!((1<<16)-1));
+		let pos=pos.map(|c|c&MASK);
 		*self.pos_id_from.entry(pos).or_insert_with(||{
 			let pos_id=PositionId::new(self.unique_pos.len() as u32);
 			self.unique_pos.push(pos);

lib/deferred_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_deferred_loader"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -10,4 +10,4 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }

lib/deferred_loader/src/deferred_loader.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use crate::loader::Loader;
 use crate::mesh::Meshes;
 use crate::texture::{RenderConfigs,Texture};
-use strafesnet_common::model::{Mesh,MeshId,RenderConfig,RenderConfigId,TextureId};
+use strafesnet_common::model::{MeshId,RenderConfig,RenderConfigId,TextureId};
 
 #[derive(Clone,Copy,Debug)]
 pub enum LoadFailureMode{
@@ -93,7 +93,7 @@ impl<H:core::hash::Hash+Eq> MeshDeferredLoader<H>{
 	pub fn into_indices(self)->impl Iterator<Item=H>{
 		self.mesh_id_from_asset_id.into_keys()
 	}
-	pub fn into_meshes<'a,L:Loader<Resource=Mesh,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes,L::Error>{
+	pub fn into_meshes<'a,M:Clone,L:Loader<Resource=M,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes<M>,L::Error>{
 		let mut mesh_list=vec![None;self.mesh_id_from_asset_id.len()];
 		for (index,mesh_id) in self.mesh_id_from_asset_id{
 			let resource_result=loader.load(index);

lib/deferred_loader/src/mesh.rs

@@ -1,15 +1,15 @@
-use strafesnet_common::model::{Mesh,MeshId};
+use strafesnet_common::model::MeshId;
 
-pub struct Meshes{
-	meshes:Vec<Option<Mesh>>,
+pub struct Meshes<M>{
+	meshes:Vec<Option<M>>,
 }
-impl Meshes{
-	pub(crate) const fn new(meshes:Vec<Option<Mesh>>)->Self{
+impl<M> Meshes<M>{
+	pub(crate) const fn new(meshes:Vec<Option<M>>)->Self{
 		Self{
 			meshes,
 		}
 	}
-	pub fn consume(self)->impl Iterator<Item=(MeshId,Mesh)>{
+	pub fn consume(self)->impl Iterator<Item=(MeshId,M)>{
 		self.meshes.into_iter().enumerate().filter_map(|(mesh_id,maybe_mesh)|
 			maybe_mesh.map(|mesh|(MeshId::new(mesh_id as u32),mesh))
 		)

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"

lib/fixed_wide/src/fixed.rs

@@ -233,6 +233,11 @@ impl FixedFromFloatError{
 		}
 	}
 }
+impl core::fmt::Display for FixedFromFloatError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
 macro_rules! impl_from_float {
 	( $decode:ident, $input: ty, $mantissa_bits:expr ) => {
 		impl<const N:usize,const F:usize> TryFrom<$input> for Fixed<N,F>{

lib/rbx_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_rbx_loader"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,11 @@ glam = "0.30.0"
 lazy-regex = "3.1.0"
 rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
-rbx_mesh = "0.3.1"
+rbx_mesh = "0.5.0"
+rbx_reflection = "5.0.0"
 rbx_reflection_database = "1.0.0"
 rbx_xml  = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
-roblox_emulator = { version = "0.5.0", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.0", path = "../deferred_loader", registry = "strafesnet" }
+roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }

lib/rbx_loader/src/error.rs

@@ -0,0 +1,245 @@
+use std::collections::HashSet;
+use std::num::ParseIntError;
+
+use strafesnet_common::gameplay_modes::{StageId,ModeId};
+use strafesnet_common::integer::{FixedFromFloatError,Planar64TryFromFloatError};
+
+/// A collection of errors which can be ignored at your peril
+#[derive(Debug,Default)]
+pub struct RecoverableErrors{
+	/// A basepart has an invalid / missing property.
+	pub basepart_property:Vec<InstancePath>,
+	/// A part has an unconvertable CFrame.
+	pub basepart_cframe:Vec<CFrameError>,
+	/// A part has an unconvertable Velocity.
+	pub basepart_velocity:Vec<Planar64ConvertError>,
+	/// A part has an invalid / missing property.
+	pub part_property:Vec<InstancePath>,
+	/// A part has an invalid shape.
+	pub part_shape:Vec<ShapeError>,
+	/// A meshpart has an invalid / missing property.
+	pub meshpart_property:Vec<InstancePath>,
+	/// A meshpart has no mesh.
+	pub meshpart_content:Vec<InstancePath>,
+	/// A basepart has an unsupported subclass.
+	pub unsupported_class:HashSet<String>,
+	/// A decal has an invalid / missing property.
+	pub decal_property:Vec<InstancePath>,
+	/// A decal has an invalid normal_id.
+	pub normal_id:Vec<NormalIdError>,
+	/// A texture has an invalid / missing property.
+	pub texture_property:Vec<InstancePath>,
+	/// A mode_id failed to parse.
+	pub mode_id_parse_int:Vec<ParseIntContext>,
+	/// There is a duplicate mode.
+	pub duplicate_mode:HashSet<ModeId>,
+	/// A mode_id failed to parse.
+	pub stage_id_parse_int:Vec<ParseIntContext>,
+	/// A Stage was duplicated leading to undefined behaviour.
+	pub duplicate_stage:HashSet<DuplicateStageError>,
+	/// A WormholeOut id failed to parse.
+	pub wormhole_out_id_parse_int:Vec<ParseIntContext>,
+	/// A WormholeOut was duplicated leading to undefined behaviour.
+	pub duplicate_wormhole_out:HashSet<u32>,
+	/// A WormholeIn id failed to parse.
+	pub wormhole_in_id_parse_int:Vec<ParseIntContext>,
+	/// A jump limit failed to parse.
+	pub jump_limit_parse_int:Vec<ParseIntContext>,
+}
+
+impl RecoverableErrors{
+	pub fn count(&self)->usize{
+		self.basepart_property.len()+
+		self.basepart_cframe.len()+
+		self.basepart_velocity.len()+
+		self.part_property.len()+
+		self.part_shape.len()+
+		self.meshpart_property.len()+
+		self.meshpart_content.len()+
+		self.unsupported_class.len()+
+		self.decal_property.len()+
+		self.normal_id.len()+
+		self.texture_property.len()+
+		self.mode_id_parse_int.len()+
+		self.duplicate_mode.len()+
+		self.stage_id_parse_int.len()+
+		self.duplicate_stage.len()+
+		self.wormhole_out_id_parse_int.len()+
+		self.duplicate_wormhole_out.len()+
+		self.wormhole_in_id_parse_int.len()+
+		self.jump_limit_parse_int.len()
+	}
+}
+
+fn write_comma_separated<T>(
+	f:&mut std::fmt::Formatter<'_>,
+	mut it:impl Iterator<Item=T>,
+	custom_write:impl Fn(&mut std::fmt::Formatter<'_>,T)->std::fmt::Result
+)->std::fmt::Result{
+	if let Some(t)=it.next(){
+		custom_write(f,t)?;
+		for t in it{
+			write!(f,", ")?;
+			custom_write(f,t)?;
+		}
+	}
+	Ok(())
+}
+
+macro_rules! write_instance_path_error{
+	($f:ident,$self:ident,$field:ident,$class:literal,$class_plural:literal,$problem:literal)=>{
+		let len=$self.$field.len();
+		if len!=0{
+			let plural=if len==1{$class}else{$class_plural};
+			write!($f,"The following {plural} {}: ",$problem)?;
+			write_comma_separated($f,$self.$field.iter(),|f,InstancePath(path)|
+				write!(f,"{path}")
+			)?;
+			writeln!($f)?;
+		}
+	};
+}
+macro_rules! write_duplicate_error{
+	($f:ident,$self:ident,$field:ident,$class:literal,$class_plural:literal)=>{
+		let len=$self.$field.len();
+		if len!=0{
+			let plural=if len==1{$class}else{$class_plural};
+			write!($f,"The following {plural} duplicates: ")?;
+			write_comma_separated($f,$self.$field.iter(),|f,id|
+				write!(f,"{id}")
+			)?;
+			writeln!($f)?;
+		}
+	};
+}
+macro_rules! write_bespoke_error{
+	($f:ident,$self:ident,$field:ident,$class:literal,$class_plural:literal,$problem:literal,$path_field:ident,$error_field:ident)=>{
+		let len=$self.$field.len();
+		if len!=0{
+			let plural=if len==1{$class}else{$class_plural};
+			write!($f,"The following {plural} {}: ",$problem)?;
+			write_comma_separated($f,$self.$field.iter(),|f,context|
+				write!(f,"{} ({})",context.$path_field,context.$error_field)
+			)?;
+			writeln!($f)?;
+		}
+	};
+}
+
+impl core::fmt::Display for RecoverableErrors{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write_instance_path_error!(f,self,basepart_property,"BasePart is","BaseParts are","missing a property");
+		write_bespoke_error!(f,self,basepart_cframe,"BasePart","BaseParts","CFrame float convert failed",path,error);
+		write_bespoke_error!(f,self,basepart_velocity,"BasePart","BaseParts","Velocity float convert failed",path,error);
+		write_instance_path_error!(f,self,part_property,"Part is","Parts are","missing a property");
+		write_bespoke_error!(f,self,part_shape,"Part","Parts","Shape is invalid",path,shape);
+		write_instance_path_error!(f,self,meshpart_property,"MeshPart is","MeshParts are","missing a property");
+		write_instance_path_error!(f,self,meshpart_content,"MeshPart has","MeshParts have","no mesh");
+		{
+			let len=self.unsupported_class.len();
+			if len!=0{
+				let plural=if len==1{"Class is"}else{"Classes are"};
+				write!(f,"The following {plural} not supported: ")?;
+				write_comma_separated(f,self.unsupported_class.iter(),|f,classname|write!(f,"{classname}"))?;
+				writeln!(f)?;
+			}
+		}
+		write_instance_path_error!(f,self,decal_property,"Decal is","Decals are","missing a property");
+		write_bespoke_error!(f,self,normal_id,"Decal","Decals","NormalId is invalid",path,normal_id);
+		write_instance_path_error!(f,self,texture_property,"Texture is","Textures are","missing a property");
+		write_bespoke_error!(f,self,mode_id_parse_int,"ModeId","ModeIds","failed to parse",context,error);
+		write_duplicate_error!(f,self,duplicate_mode,"ModeId has","ModeIds have");
+		write_bespoke_error!(f,self,stage_id_parse_int,"StageId","StageIds","failed to parse",context,error);
+		write_duplicate_error!(f,self,duplicate_stage,"StageId has","StageIds have");
+		write_bespoke_error!(f,self,wormhole_out_id_parse_int,"WormholeOutId","WormholeOutIds","failed to parse",context,error);
+		write_duplicate_error!(f,self,duplicate_wormhole_out,"WormholeOutId has","WormholeOutIds have");
+		write_bespoke_error!(f,self,wormhole_in_id_parse_int,"WormholeInId","WormholeInIds","failed to parse",context,error);
+		write_bespoke_error!(f,self,jump_limit_parse_int,"jump limit","jump limits","failed to parse",context,error);
+		Ok(())
+	}
+}
+
+/// A Decal was missing required properties
+#[derive(Debug)]
+pub struct InstancePath(pub String);
+
+impl core::fmt::Display for InstancePath{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		self.0.fmt(f)
+	}
+}
+
+impl InstancePath{
+	pub fn new(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->InstancePath{
+		let mut names:Vec<_>=core::iter::successors(
+			Some(instance),
+			|i|dom.get_by_ref(i.parent())
+		).map(
+			|i|i.name.as_str()
+		).collect();
+		// discard the name of the root object
+		names.pop();
+		names.reverse();
+		InstancePath(names.join("."))
+	}
+}
+
+#[derive(Debug)]
+pub struct ParseIntContext{
+	pub context:String,
+	pub error:ParseIntError,
+}
+impl ParseIntContext{
+	pub fn parse<T:core::str::FromStr<Err=ParseIntError>>(input:&str)->Result<T,Self>{
+		input.parse().map_err(|error|ParseIntContext{
+			context:input.to_owned(),
+			error,
+		})
+	}
+}
+
+#[derive(Debug)]
+pub struct NormalIdError{
+	pub path:InstancePath,
+	pub normal_id:u32,
+}
+
+#[derive(Debug)]
+pub struct ShapeError{
+	pub path:InstancePath,
+	pub shape:u32,
+}
+
+#[derive(Debug)]
+pub enum CFrameErrorType{
+	ZeroDeterminant,
+	Convert(FixedFromFloatError),
+}
+impl core::fmt::Display for CFrameErrorType{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+
+#[derive(Debug)]
+pub struct CFrameError{
+	pub path:InstancePath,
+	pub error:CFrameErrorType,
+}
+
+#[derive(Debug)]
+pub struct Planar64ConvertError{
+	pub path:InstancePath,
+	pub error:Planar64TryFromFloatError,
+}
+
+#[derive(Debug,Hash,Eq,PartialEq)]
+pub struct DuplicateStageError{
+	pub mode_id:ModeId,
+	pub stage_id:StageId,
+}
+impl core::fmt::Display for DuplicateStageError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{}-Spawn{}",self.mode_id,self.stage_id.get())
+	}
+}

lib/rbx_loader/src/lib.rs

@@ -1,13 +1,18 @@
 use std::io::Read;
 use rbx_dom_weak::WeakDom;
 use roblox_emulator::context::Context;
+use strafesnet_common::map::CompleteMap;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
 
+pub use error::RecoverableErrors;
+pub use roblox_emulator::runner::Error as RunnerError;
+
 mod rbx;
 mod mesh;
+mod error;
 mod union;
 pub mod loader;
-mod primitives;
+pub mod primitives;
 
 pub mod data{
 	pub struct RobloxMeshBytes(Vec<u8>);
@@ -28,7 +33,7 @@ impl Model{
 	fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
 		to_snf(self,failure_mode)
 	}
 }
@@ -48,18 +53,20 @@ impl Place{
 			context,
 		})
 	}
-	pub fn run_scripts(&mut self){
+	pub fn run_scripts(&mut self)->Result<Vec<RunnerError>,RunnerError>{
 		let Place{context}=self;
-		let runner=roblox_emulator::runner::Runner::new().unwrap();
+		let runner=roblox_emulator::runner::Runner::new()?;
 		let scripts=context.scripts();
-		let runnable=runner.runnable_context(context).unwrap();
+		let runnable=runner.runnable_context(context)?;
+		let mut errors=Vec::new();
 		for script in scripts{
 			if let Err(e)=runnable.run_script(script){
-				println!("runner error: {e}");
+				errors.push(e);
 			}
 		}
+		Ok(errors)
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
 		to_snf(self,failure_mode)
 	}
 }
@@ -123,7 +130,7 @@ impl From<loader::MeshError> for LoadError{
 	}
 }
 
-fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
 	let dom=dom.as_ref();
 
 	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
@@ -143,7 +150,5 @@ fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<strafesn
 	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);
-
-	Ok(map)
+	Ok(map_step2.add_render_configs_and_textures(render_configs))
 }

lib/rbx_loader/src/loader.rs

@@ -18,7 +18,6 @@ fn read_entire_file(path:impl AsRef<std::path::Path>)->Result<Vec<u8>,std::io::E
 	Ok(data)
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum TextureError{
 	Io(std::io::Error),
@@ -59,7 +58,6 @@ impl Loader for TextureLoader{
 	}
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum MeshError{
 	Io(std::io::Error),
@@ -118,7 +116,7 @@ pub struct MeshIndex<'a>{
 	content:&'a str,
 }
 impl MeshIndex<'_>{
-	pub fn file_mesh(content:&str)->MeshIndex{
+	pub fn file_mesh(content:&str)->MeshIndex<'_>{
 		MeshIndex{
 			mesh_type:MeshType::FileMesh,
 			content,
@@ -143,6 +141,12 @@ impl MeshIndex<'_>{
 	}
 }
 
+#[derive(Clone)]
+pub struct MeshWithSize{
+	pub(crate) mesh:Mesh,
+	pub(crate) size:strafesnet_common::integer::Planar64Vec3,
+}
+
 pub struct MeshLoader;
 impl MeshLoader{
 	pub fn new()->Self{
@@ -152,7 +156,7 @@ impl MeshLoader{
 impl Loader for MeshLoader{
 	type Error=MeshError;
 	type Index<'a>=MeshIndex<'a>;
-	type Resource=Mesh;
+	type Resource=MeshWithSize;
 	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let mesh=match index.mesh_type{
 			MeshType::FileMesh=>{

lib/rbx_loader/src/mesh.rs

@@ -1,9 +1,12 @@
 use std::collections::HashMap;
 
 use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
-use strafesnet_common::{integer::vec3,model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId}};
+use strafesnet_common::aabb::Aabb;
+use strafesnet_common::integer::vec3;
+use strafesnet_common::model::{self,ColorId,IndexedVertex,PolygonGroup,PolygonList,RenderConfigId,VertexId};
+
+use crate::loader::MeshWithSize;
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
@@ -16,69 +19,44 @@ impl std::fmt::Display for Error{
 }
 impl std::error::Error for Error{}
 
-fn ingest_vertices2<
-	AcquirePosId,
-	AcquireTexId,
-	AcquireNormalId,
-	AcquireColorId,
-	AcquireVertexId,
->(
+fn ingest_vertices2(
 	vertices:Vec<Vertex2>,
-	acquire_pos_id:&mut AcquirePosId,
-	acquire_tex_id:&mut AcquireTexId,
-	acquire_normal_id:&mut AcquireNormalId,
-	acquire_color_id:&mut AcquireColorId,
-	acquire_vertex_id:&mut AcquireVertexId,
-)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>
-where
-	AcquirePosId:FnMut([f32;3])->Result<PositionId,Error>,
-	AcquireTexId:FnMut([f32;2])->TextureCoordinateId,
-	AcquireNormalId:FnMut([f32;3])->Result<NormalId,Error>,
-	AcquireColorId:FnMut([f32;4])->ColorId,
-	AcquireVertexId:FnMut(IndexedVertex)->VertexId,
-{
+	mb:&mut model::MeshBuilder,
+)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>{
 	//this monster is collecting a map of old_vertices_index -> unique_vertices_index
 	//while also doing the inserting unique entries into lists simultaneously
 	Ok(vertices.into_iter().enumerate().map(|(vertex_id,vertex)|Ok((
 		rbx_mesh::mesh::VertexId2(vertex_id as u32),
-		acquire_vertex_id(IndexedVertex{
-			pos:acquire_pos_id(vertex.pos)?,
-			tex:acquire_tex_id(vertex.tex),
-			normal:acquire_normal_id(vertex.norm)?,
-			color:acquire_color_id(vertex.color.map(|f|f as f32/255.0f32))
-		}),
-	))).collect::<Result<_,_>>()?)
+		{
+			let vertex=IndexedVertex{
+				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
+				tex:mb.acquire_tex_id(glam::Vec2::from_array(vertex.tex)),
+				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
+				color:mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)))
+			};
+			mb.acquire_vertex_id(vertex)
+		}
+	))).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)
 }
-fn ingest_vertices_truncated2<
-	AcquirePosId,
-	AcquireTexId,
-	AcquireNormalId,
-	AcquireVertexId,
->(
+fn ingest_vertices_truncated2(
 	vertices:Vec<Vertex2Truncated>,
-	acquire_pos_id:&mut AcquirePosId,
-	acquire_tex_id:&mut AcquireTexId,
-	acquire_normal_id:&mut AcquireNormalId,
+	mb:&mut model::MeshBuilder,
 	static_color_id:ColorId,//pick one color and fill everything with it
-	acquire_vertex_id:&mut AcquireVertexId,
-)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>
-where
-	AcquirePosId:FnMut([f32;3])->Result<PositionId,Error>,
-	AcquireTexId:FnMut([f32;2])->TextureCoordinateId,
-	AcquireNormalId:FnMut([f32;3])->Result<NormalId,Error>,
-	AcquireVertexId:FnMut(IndexedVertex)->VertexId,
-{
+)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>{
 	//this monster is collecting a map of old_vertices_index -> unique_vertices_index
 	//while also doing the inserting unique entries into lists simultaneously
 	Ok(vertices.into_iter().enumerate().map(|(vertex_id,vertex)|Ok((
 		rbx_mesh::mesh::VertexId2(vertex_id as u32),
-		acquire_vertex_id(IndexedVertex{
-			pos:acquire_pos_id(vertex.pos)?,
-			tex:acquire_tex_id(vertex.tex),
-			normal:acquire_normal_id(vertex.norm)?,
-			color:static_color_id
-		}),
-	))).collect::<Result<_,_>>()?)
+		{
+			let vertex=IndexedVertex{
+				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
+				tex:mb.acquire_tex_id(glam::Vec2::from_array(vertex.tex)),
+				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
+				color:static_color_id,
+			};
+			mb.acquire_vertex_id(vertex)
+		}
+	))).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)
 }
 
 fn ingest_faces2_lods3(
@@ -95,123 +73,74 @@ fn ingest_faces2_lods3(
 	))
 }
 
-pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Mesh,Error>{
+pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithSize,Error>{
 	//generate that mesh boi
-	let mut unique_pos=Vec::new();
-	let mut pos_id_from=HashMap::new();
-	let mut unique_tex=Vec::new();
-	let mut tex_id_from=HashMap::new();
-	let mut unique_normal=Vec::new();
-	let mut normal_id_from=HashMap::new();
-	let mut unique_color=Vec::new();
-	let mut color_id_from=HashMap::new();
-	let mut unique_vertices=Vec::new();
-	let mut vertex_id_from=HashMap::new();
 	let mut polygon_groups=Vec::new();
-	let mut acquire_pos_id=|pos|{
-		let p=vec3::try_from_f32_array(pos).map_err(Error::Planar64Vec3)?;
-		Ok(PositionId::new(*pos_id_from.entry(p).or_insert_with(||{
-			let pos_id=unique_pos.len();
-			unique_pos.push(p);
-			pos_id
-		}) as u32))
-	};
-	let mut acquire_tex_id=|tex|{
-		let h=bytemuck::cast::<[f32;2],[u32;2]>(tex);
-		TextureCoordinateId::new(*tex_id_from.entry(h).or_insert_with(||{
-			let tex_id=unique_tex.len();
-			unique_tex.push(glam::Vec2::from_array(tex));
-			tex_id
-		}) as u32)
-	};
-	let mut acquire_normal_id=|normal|{
-		let n=vec3::try_from_f32_array(normal).map_err(Error::Planar64Vec3)?;
-		Ok(NormalId::new(*normal_id_from.entry(n).or_insert_with(||{
-			let normal_id=unique_normal.len();
-			unique_normal.push(n);
-			normal_id
-		}) as u32))
-	};
-	let mut acquire_color_id=|color|{
-		let h=bytemuck::cast::<[f32;4],[u32;4]>(color);
-		ColorId::new(*color_id_from.entry(h).or_insert_with(||{
-			let color_id=unique_color.len();
-			unique_color.push(glam::Vec4::from_array(color));
-			color_id
-		}) as u32)
-	};
-	let mut acquire_vertex_id=|vertex:IndexedVertex|{
-		VertexId::new(*vertex_id_from.entry(vertex.clone()).or_insert_with(||{
-			let vertex_id=unique_vertices.len();
-			unique_vertices.push(vertex);
-			vertex_id
-		}) as u32)
-	};
+	let mut mb=model::MeshBuilder::new();
 	match rbx_mesh::read_versioned(roblox_mesh_bytes.cursor()).map_err(Error::RbxMesh)?{
-		rbx_mesh::mesh::VersionedMesh::Version1(mesh)=>{
-			let color_id=acquire_color_id([1.0f32;4]);
+		rbx_mesh::mesh::Mesh::V1(mesh)=>{
+			let color_id=mb.acquire_color_id(glam::Vec4::ONE);
 			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.vertices.chunks_exact(3).map(|trip|{
-				let mut ingest_vertex1=|vertex:&rbx_mesh::mesh::Vertex1|Ok(acquire_vertex_id(IndexedVertex{
-					pos:acquire_pos_id(vertex.pos)?,
-					tex:acquire_tex_id([vertex.tex[0],vertex.tex[1]]),
-					normal:acquire_normal_id(vertex.norm)?,
-					color:color_id,
-				}));
+				let mut ingest_vertex1=|vertex:&rbx_mesh::mesh::Vertex1|{
+					let vertex=IndexedVertex{
+						pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
+						tex:mb.acquire_tex_id(glam::vec2(vertex.tex[0],vertex.tex[1])),
+						normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
+						color:color_id,
+					};
+					Ok(mb.acquire_vertex_id(vertex))
+				};
 				Ok(vec![ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?])
-			}).collect::<Result<_,_>>()?)));
+			}).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)));
 		},
-		rbx_mesh::mesh::VersionedMesh::Version2(mesh)=>{
+		rbx_mesh::mesh::Mesh::V2(mesh)=>{
 			let vertex_id_map=match mesh.header.sizeof_vertex{
 				rbx_mesh::mesh::SizeOfVertex2::Truncated=>{
 					//pick white and make all the vertices white
-					let color_id=acquire_color_id([1.0f32;4]);
-					ingest_vertices_truncated2(mesh.vertices_truncated,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,color_id,&mut acquire_vertex_id)
+					let color_id=mb.acquire_color_id(glam::Vec4::ONE);
+					ingest_vertices_truncated2(mesh.vertices_truncated,&mut mb,color_id)
 				},
-				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id),
+				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
 			}?;
 			//one big happy group for all the faces
 			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|face|
 				vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
 			).collect())));
 		},
-		rbx_mesh::mesh::VersionedMesh::Version3(mesh)=>{
+		rbx_mesh::mesh::Mesh::V3(mesh)=>{
 			let vertex_id_map=match mesh.header.sizeof_vertex{
 				rbx_mesh::mesh::SizeOfVertex2::Truncated=>{
-					let color_id=acquire_color_id([1.0f32;4]);
-					ingest_vertices_truncated2(mesh.vertices_truncated,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,color_id,&mut acquire_vertex_id)
+					let color_id=mb.acquire_color_id(glam::Vec4::ONE);
+					ingest_vertices_truncated2(mesh.vertices_truncated,&mut mb,color_id)
 				},
-				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id),
+				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
 			}?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
-		rbx_mesh::mesh::VersionedMesh::Version4(mesh)=>{
-			let vertex_id_map=ingest_vertices2(
-				mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id
-			)?;
+		rbx_mesh::mesh::Mesh::V4(mesh)=>{
+			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb)?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
-		rbx_mesh::mesh::VersionedMesh::Version5(mesh)=>{
-			let vertex_id_map=ingest_vertices2(
-				mesh.vertices,&mut acquire_pos_id,&mut acquire_tex_id,&mut acquire_normal_id,&mut acquire_color_id,&mut acquire_vertex_id
-			)?;
+		rbx_mesh::mesh::Mesh::V5(mesh)=>{
+			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb)?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 	}
-	Ok(model::Mesh{
-		unique_pos,
-		unique_normal,
-		unique_tex,
-		unique_color,
-		unique_vertices,
+	let mesh=mb.build(
 		polygon_groups,
 		//these should probably be moved to the model...
 		//but what if models want to use the same texture
-		graphics_groups:vec![model::IndexedGraphicsGroup{
+		vec![model::IndexedGraphicsGroup{
 			render:RenderConfigId::new(0),
 			//the lowest lod is highest quality
 			groups:vec![model::PolygonGroupId::new(0)]
 		}],
 		//disable physics
-		physics_groups:Vec::new(),
-	})
+		Vec::new(),
+	);
+	let mut aabb=Aabb::default();
+	for &point in &mesh.unique_pos{
+		aabb.grow(point);
+	}
+	Ok(MeshWithSize{mesh,size:aabb.size()})
 }

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

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
-use crate::loader::MeshIndex;
+use crate::error::{RecoverableErrors,CFrameError,CFrameErrorType,DuplicateStageError,InstancePath,NormalIdError,Planar64ConvertError,ParseIntContext,ShapeError};
+use crate::loader::{MeshWithSize,MeshIndex};
 use crate::primitives::{self,CubeFace,CubeFaceDescription,WedgeFaceDescription,CornerWedgeFaceDescription,FaceDescription,Primitives};
-use strafesnet_common::aabb::Aabb;
 use strafesnet_common::map;
 use strafesnet_common::model;
 use strafesnet_common::gameplay_modes::{NormalizedModes,Mode,ModeId,ModeUpdate,ModesBuilder,Stage,StageElement,StageElementBehaviour,StageId,Zone};
 use strafesnet_common::gameplay_style;
 use strafesnet_common::gameplay_attributes as attr;
-use strafesnet_common::integer::{self,vec3,Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
+use strafesnet_common::integer::{self,vec3,Planar64TryFromFloatError,Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
 use strafesnet_common::model::RenderConfigId;
 use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,MeshDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
@@ -18,54 +18,50 @@ fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
 	rbx_dom_weak::ustr(s)
 }
 
-fn recursive_collect_superclass(
-	objects:&mut std::vec::Vec<rbx_dom_weak::types::Ref>,
-	dom:&rbx_dom_weak::WeakDom,
-	instance:&rbx_dom_weak::Instance,
-	superclass:&str
-){
-	let instance=instance;
-	let db=rbx_reflection_database::get();
-	let Some(superclass)=db.classes.get(superclass)else{
-		return;
-	};
-	objects.extend(
-		dom.descendants_of(instance.referent()).filter_map(|instance|{
-			let class=db.classes.get(instance.class.as_str())?;
-			db.has_superclass(class,superclass).then(||instance.referent())
-		})
-	);
-}
-
-fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
-	Planar64Affine3::new(
+fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Result<Planar64Affine3,Planar64TryFromFloatError>{
+	Ok(Planar64Affine3::new(
 		Planar64Mat3::from_cols([
-			vec3::try_from_f32_array([cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x]).unwrap()
-			*integer::try_from_f32(size.x/2.0).unwrap(),
-			vec3::try_from_f32_array([cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y]).unwrap()
-			*integer::try_from_f32(size.y/2.0).unwrap(),
-			vec3::try_from_f32_array([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z]).unwrap()
-			*integer::try_from_f32(size.z/2.0).unwrap(),
-			].map(|t|t.narrow_1().unwrap())),
-		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z]).unwrap()
-	)
+			(vec3::try_from_f32_array([cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x])?
+			*integer::try_from_f32(size.x/2.0)?).narrow_1().unwrap(),//.map_err(Planar64ConvertError::Narrow)?
+			(vec3::try_from_f32_array([cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y])?
+			*integer::try_from_f32(size.y/2.0)?).narrow_1().unwrap(),//.map_err(Planar64ConvertError::Narrow)?
+			(vec3::try_from_f32_array([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z])?
+			*integer::try_from_f32(size.z/2.0)?).narrow_1().unwrap(),//.map_err(Planar64ConvertError::Narrow)?
+		]),
+		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z])?
+	))
 }
 
-fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
+enum GetAttributesError{
+	ModeIdParseInt(ParseIntContext),
+	DuplicateMode(ModeId),
+	StageIdParseInt(ParseIntContext),
+	DuplicateStage(DuplicateStageError),
+	WormholeOutIdParseInt(ParseIntContext),
+	DuplicateWormholeOut(u32),
+	WormholeInIdParseInt(ParseIntContext),
+	JumpLimitParseInt(ParseIntContext),
+}
+
+fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->Result<attr::CollisionAttributes,GetAttributesError>{
 	let mut general=attr::GeneralAttributes::default();
 	let mut intersecting=attr::IntersectingAttributes::default();
 	let mut contacting=attr::ContactingAttributes::default();
 	let mut force_can_collide=can_collide;
 	let mut force_intersecting=false;
+	let mut allow_booster=true;
 	match name{
 		"Water"=>{
 			force_can_collide=false;
+			allow_booster=false;
 			//TODO: read stupid CustomPhysicalProperties
 			intersecting.water=Some(attr::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
 		},
 		"Accelerator"=>{
 			//although the new game supports collidable accelerators, this is a roblox compatability map loader
 			force_can_collide=false;
+			// Accelerator is not allowed to be booster in roblox
+			allow_booster=false;
 			general.accelerator=Some(attr::Accelerator{acceleration:velocity});
 		},
 		// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(model::TeleportBehaviour::StageElement(attr::StageElement{
@@ -74,17 +70,21 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		// 	force:false,
 		// 	behaviour:model::StageElementBehaviour::Unordered
 		// })),
-		"SetVelocity"=>general.trajectory=Some(attr::SetTrajectory::Velocity(velocity)),
+		"SetVelocity"=>{
+			allow_booster=false;
+			general.trajectory=Some(attr::SetTrajectory::Velocity(velocity));
+		},
 		"MapStart"=>{
 			force_can_collide=false;
 			force_intersecting=true;
+			let mode_id=ModeId::MAIN;
 			modes_builder.insert_mode(
-				ModeId::MAIN,
+				mode_id,
 				Mode::empty(
 					gameplay_style::StyleModifiers::roblox_bhop(),
 					model_id
 				)
-			).unwrap();
+			).map_err(|_|GetAttributesError::DuplicateMode(mode_id))?;
 		},
 		"MapFinish"=>{
 			force_can_collide=false;
@@ -124,26 +124,30 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					"BonusStart"=>{
 						force_can_collide=false;
 						force_intersecting=true;
+						let mode_id=ModeId::new(ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::ModeIdParseInt)?);
 						modes_builder.insert_mode(
-							ModeId::new(captures[2].parse::<u32>().unwrap()),
+							mode_id,
 							Mode::empty(
 								gameplay_style::StyleModifiers::roblox_bhop(),
 								model_id
 							)
-						).unwrap();
+						).map_err(|_|GetAttributesError::DuplicateMode(mode_id))?;
 					},
 					"WormholeOut"=>{
 						//the PhysicsModelId has to exist for it to be teleported to!
 						force_intersecting=true;
 						//this object is not special in strafe client, but the roblox mapping needs to be converted to model id
-						assert!(wormhole_id_to_out_model.insert(captures[2].parse::<u32>().unwrap(),model_id).is_none(),"Cannot have multiple WormholeOut with same id");
+						let wormhole_id=ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::WormholeOutIdParseInt)?;
+						if wormhole_id_to_out_model.insert(wormhole_id,model_id).is_some(){
+							return Err(GetAttributesError::DuplicateWormholeOut(wormhole_id));
+						}
 					},
 					_=>(),
 				}
 			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
-				let stage_id=StageId::new(captures[3].parse::<u32>().unwrap());
+				let stage_id=StageId::new(ParseIntContext::parse(&captures[3]).map_err(GetAttributesError::StageIdParseInt)?);
 				let stage_element=StageElement::new(
 					//stage_id:
 					stage_id,
@@ -155,11 +159,12 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					//behaviour:
 					match &captures[2]{
 						"Spawn"=>{
+							let mode_id=ModeId::MAIN;
 							modes_builder.insert_stage(
-								ModeId::MAIN,
+								mode_id,
 								stage_id,
 								Stage::empty(model_id),
-							).unwrap();
+							).map_err(|_|GetAttributesError::DuplicateStage(DuplicateStageError{mode_id,stage_id}))?;
 							//TODO: let denormalize handle this
 							StageElementBehaviour::SpawnAt
 						},
@@ -169,7 +174,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						"Trigger"=>{force_can_collide=false;StageElementBehaviour::Trigger},
 						"Teleport"=>{force_can_collide=false;StageElementBehaviour::Teleport},
 						"Platform"=>StageElementBehaviour::Platform,
-						_=>panic!("regex1[2] messed up bad"),
+						_=>unreachable!("regex1[2] messed up bad"),
 					},
 					None
 				);
@@ -192,30 +197,33 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 								StageId::FIRST,
 								false,
 								StageElementBehaviour::Check,
-								Some(captures[2].parse::<u8>().unwrap())
+								Some(ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::JumpLimitParseInt)?)
 							)
 						),
 					),
 					"WormholeIn"=>{
 						force_can_collide=false;
 						force_intersecting=true;
-						assert!(wormhole_in_model_to_id.insert(model_id,captures[2].parse::<u32>().unwrap()).is_none(),"Impossible");
+						let wormhole_id=ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::WormholeInIdParseInt)?;
+						// It is impossible for two different objects to have the same model id
+						assert!(wormhole_in_model_to_id.insert(model_id,wormhole_id).is_none(),"Impossible");
 					},
-					_=>panic!("regex2[1] messed up bad"),
+					_=>unreachable!("regex2[1] messed up bad"),
 				}
 			}else if let Some(captures)=lazy_regex::regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
 			.captures(other){
 				force_can_collide=false;
 				force_intersecting=true;
+				let mode_id=ModeId::new(ParseIntContext::parse(&captures[2]).map_err(GetAttributesError::ModeIdParseInt)?);
 				modes_builder.push_mode_update(
-					ModeId::new(captures[2].parse::<u32>().unwrap()),
+					mode_id,
 					ModeUpdate::zone(
 						model_id,
 						//zone:
 						match &captures[1]{
 							"Finish"=>Zone::Finish,
 							"Anticheat"=>Zone::Anticheat,
-							_=>panic!("regex3[1] messed up bad"),
+							_=>unreachable!("regex3[1] messed up bad"),
 						},
 					),
 				);
@@ -234,10 +242,10 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}
 	}
 	//need some way to skip this
-	if velocity!=vec3::ZERO{
+	if allow_booster&&velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
-	match force_can_collide{
+	Ok(match force_can_collide{
 		true=>{
 			match name{
 				"Bounce"=>contacting.contact_behaviour=Some(attr::ContactingBehaviour::Elastic(u32::MAX)),
@@ -255,7 +263,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}else{
 			attr::CollisionAttributes::Decoration
 		},
-	}
+	})
 }
 
 #[derive(Clone,Copy)]
@@ -401,21 +409,25 @@ fn get_content_url(content:&rbx_dom_weak::types::Content)->Option<&str>{
 }
 
 fn get_texture_description<'a>(
-	temp_objects:&mut Vec<rbx_dom_weak::types::Ref>,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
+	recoverable_errors:&mut RecoverableErrors,
+	db:&rbx_reflection::ReflectionDatabase,
 	dom:&'a rbx_dom_weak::WeakDom,
 	object:&rbx_dom_weak::Instance,
 	size:&rbx_dom_weak::types::Vector3,
 )->RobloxPartDescription{
 	//use the biggest one and cut it down later...
 	let mut part_texture_description=RobloxPartDescription::default();
-	temp_objects.clear();
-	recursive_collect_superclass(temp_objects,&dom,object,"Decal");
-	for &mut decal_ref in temp_objects{
-		let Some(decal)=dom.get_by_ref(decal_ref) else{
-			println!("Decal get_by_ref failed");
-			continue;
-		};
+	let decal=&db.classes["Decal"];
+	let decals=object.children().iter().filter_map(|&referent|{
+		let instance=dom.get_by_ref(referent)?;
+		db.classes.get(instance.class.as_str()).is_some_and(|class|
+			db.has_superclass(class,decal)
+		).then_some(instance)
+	});
+	for decal in decals{
+		// decals should always have these properties,
+		// but it is not guaranteed by the rbx_dom_weak data structure.
 		let (
 			Some(rbx_dom_weak::types::Variant::Content(content)),
 			Some(rbx_dom_weak::types::Variant::Enum(normalid)),
@@ -427,16 +439,16 @@ fn get_texture_description<'a>(
 			decal.properties.get(&static_ustr("Color3")),
 			decal.properties.get(&static_ustr("Transparency")),
 		)else{
-			println!("Decal is missing a required property");
+			recoverable_errors.decal_property.push(InstancePath::new(dom,decal));
 			continue;
 		};
-		let texture_id=match content.value(){
-			rbx_dom_weak::types::ContentType::Uri(uri)=>Some(uri.as_str()),
-			_=>None,
-		};
+		let texture_id=get_content_url(content);
 		let render_id=render_config_deferred_loader.acquire_render_config_id(texture_id);
 		let Ok(cube_face)=normalid.to_u32().try_into()else{
-			println!("NormalId is invalid");
+			recoverable_errors.normal_id.push(NormalIdError{
+				path:InstancePath::new(dom,decal),
+				normal_id:normalid.to_u32(),
+			});
 			continue;
 		};
 		let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
@@ -473,6 +485,7 @@ fn get_texture_description<'a>(
 					}
 				)
 			}else{
+				recoverable_errors.texture_property.push(InstancePath::new(dom,decal));
 				(glam::Vec4::ONE,RobloxTextureTransform::identity())
 			}
 		}else{
@@ -526,6 +539,8 @@ pub fn convert<'a>(
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
 	mesh_deferred_loader:&mut MeshDeferredLoader<MeshIndex<'a>>,
 )->PartialMap1<'a>{
+	let mut recoverable_errors=RecoverableErrors::default();
+
 	let mut deferred_models_deferred_attributes=Vec::new();
 	let mut deferred_unions_deferred_attributes=Vec::new();
 	let mut primitive_models_deferred_attributes=Vec::new();
@@ -535,63 +550,83 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let mut object_refs=Vec::new();
-	let mut temp_objects=Vec::new();
-	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),"BasePart");
-	for object_ref in object_refs {
-		if let Some(object)=dom.get_by_ref(object_ref){
-			if let (
-					Some(rbx_dom_weak::types::Variant::CFrame(cf)),
-					Some(rbx_dom_weak::types::Variant::Vector3(size)),
-					Some(rbx_dom_weak::types::Variant::Vector3(velocity)),
-					Some(rbx_dom_weak::types::Variant::Float32(transparency)),
-					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
-					Some(rbx_dom_weak::types::Variant::Bool(can_collide)),
-				) = (
-					object.properties.get(&static_ustr("CFrame")),
-					object.properties.get(&static_ustr("Size")),
-					object.properties.get(&static_ustr("Velocity")),
-					object.properties.get(&static_ustr("Transparency")),
-					object.properties.get(&static_ustr("Color")),
-					object.properties.get(&static_ustr("CanCollide")),
-				)
-			{
-				let model_transform=planar64_affine3_from_roblox(cf,size);
-
+	let db=rbx_reflection_database::get();
+	let basepart=&db.classes["BasePart"];
+	let baseparts=dom.descendants().filter(|&instance|
+		db.classes.get(instance.class.as_str()).is_some_and(|class|
+			db.has_superclass(class,basepart)
+		)
+	);
+	for object in baseparts{
+		let (
+			Some(rbx_dom_weak::types::Variant::CFrame(cf)),
+			Some(rbx_dom_weak::types::Variant::Vector3(size)),
+			Some(rbx_dom_weak::types::Variant::Vector3(velocity)),
+			Some(rbx_dom_weak::types::Variant::Float32(transparency)),
+			Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
+			Some(&rbx_dom_weak::types::Variant::Bool(can_collide)),
+		) = (
+			object.properties.get(&static_ustr("CFrame")),
+			object.properties.get(&static_ustr("Size")),
+			object.properties.get(&static_ustr("Velocity")),
+			object.properties.get(&static_ustr("Transparency")),
+			object.properties.get(&static_ustr("Color")),
+			object.properties.get(&static_ustr("CanCollide")),
+		)else{
+			recoverable_errors.basepart_property.push(InstancePath::new(dom,object));
+			continue;
+		};
+		let model_transform=match planar64_affine3_from_roblox(cf,size){
+			Ok(model_transform)=>{
 				if model_transform.matrix3.det().is_zero(){
-					let mut parent_ref=object.parent();
-					let mut full_path=object.name.clone();
-					while let Some(parent)=dom.get_by_ref(parent_ref){
-						full_path=format!("{}.{}",parent.name,full_path);
-						parent_ref=parent.parent();
-					}
-					println!("Zero determinant CFrame at location {}",full_path);
-					println!("matrix3:{}",model_transform.matrix3);
+					recoverable_errors.basepart_cframe.push(CFrameError{
+						path:InstancePath::new(dom,object),
+						error:CFrameErrorType::ZeroDeterminant,
+					});
 					continue;
 				}
+				model_transform
+			},
+			Err(e)=>{
+				recoverable_errors.basepart_cframe.push(CFrameError{
+					path:InstancePath::new(dom,object),
+					error:CFrameErrorType::Convert(e),
+				});
+				continue;
+			}
+		};
 
-				//TODO: also detect "CylinderMesh" etc here
-				let shape=match object.class.as_str(){
-					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get(&static_ustr("Shape")){
-						Shape::Primitive(shape.to_u32().try_into().expect("Funky roblox PartType"))
-					}else{
-						panic!("Part has no Shape!");
-					},
-					"TrussPart"=>Shape::Primitive(Primitives::Cube),
-					"WedgePart"=>Shape::Primitive(Primitives::Wedge),
-					"CornerWedgePart"=>Shape::Primitive(Primitives::CornerWedge),
-					"MeshPart"=>Shape::MeshPart,
-					"UnionOperation"=>Shape::PhysicsData,
-					_=>{
-						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
-						Shape::Primitive(Primitives::Cube)
-					}
+		//TODO: also detect "CylinderMesh" etc here
+		let shape=match object.class.as_str(){
+			"Part"|"Seat"|"SpawnLocation"=>{
+				let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get(&static_ustr("Shape"))else{
+					recoverable_errors.part_property.push(InstancePath::new(dom,object));
+					continue;
 				};
+				let Ok(shape)=shape.to_u32().try_into()else{
+					recoverable_errors.part_shape.push(ShapeError{
+						path:InstancePath::new(dom,object),
+						shape:shape.to_u32(),
+					});
+					continue;
+				};
+				Shape::Primitive(shape)
+			},
+			"TrussPart"|"VehicleSeat"=>Shape::Primitive(Primitives::Cube),
+			"WedgePart"=>Shape::Primitive(Primitives::Wedge),
+			"CornerWedgePart"=>Shape::Primitive(Primitives::CornerWedge),
+			"MeshPart"=>Shape::MeshPart,
+			"UnionOperation"=>Shape::PhysicsData,
+			"Terrain"=>continue,
+			_=>{
+				recoverable_errors.unsupported_class.insert(object.class.as_str().to_owned());
+				Shape::Primitive(Primitives::Cube)
+			}
+		};
 
-				let (availability,mesh_id)=match shape{
-					Shape::Primitive(primitive_shape)=>{
-				//TODO: TAB TAB
-				let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
+		let (availability,mesh_id)=match shape{
+			Shape::Primitive(primitive_shape)=>{
+				let part_texture_description=get_texture_description(render_config_deferred_loader,&mut recoverable_errors,db,dom,object,size);
 				//obscure rust syntax "slice pattern"
 				let RobloxPartDescription([
 					f0,//Cube::Right
@@ -640,66 +675,83 @@ pub fn convert<'a>(
 					mesh_id
 				};
 				(MeshAvailability::Immediate,mesh_id)
-					},
-					Shape::MeshPart=>if let (
-						Some(rbx_dom_weak::types::Variant::Content(mesh_content)),
-						Some(rbx_dom_weak::types::Variant::Content(texture_content)),
-					)=(
-						// mesh must exist
-						object.properties.get(&static_ustr("MeshContent")),
-						// texture is allowed to be none
-						object.properties.get(&static_ustr("TextureContent")),
-					){
-						let mesh_asset_id=get_content_url(mesh_content).expect("MeshPart Mesh is not a Uri");
-						let texture_asset_id=get_content_url(texture_content);
-						(
-							MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(texture_asset_id)),
-							mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id)),
-						)
-					}else{
-						panic!("Mesh has no Mesh or Texture");
-					},
-					Shape::PhysicsData=>{
-						let mut content="";
-						let mut mesh_data:&[u8]=&[];
-						let mut physics_data:&[u8]=&[];
-						if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(&static_ustr("AssetId")){
-							content=asset_id.as_ref();
-						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("MeshData")){
-							mesh_data=data.as_ref();
-						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("PhysicsData")){
-							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,size,part_texture_description.clone());
-						let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
-						(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
-					},
+			},
+			Shape::MeshPart=>{
+				let (
+					Some(rbx_dom_weak::types::Variant::Content(mesh_content)),
+					Some(rbx_dom_weak::types::Variant::Content(texture_content)),
+				)=(
+					// mesh must exist
+					object.properties.get(&static_ustr("MeshContent")),
+					// texture is allowed to be none
+					object.properties.get(&static_ustr("TextureContent")),
+				)else{
+					recoverable_errors.meshpart_property.push(InstancePath::new(dom,object));
+					continue;
 				};
-				let model_deferred_attributes=ModelDeferredAttributes{
-					mesh:mesh_id,
-					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(),
-						can_collide:*can_collide,
-						velocity:vec3::try_from_f32_array([velocity.x,velocity.y,velocity.z]).unwrap(),
-					},
+				let mesh_asset_id=match get_content_url(mesh_content){
+					Some(mesh_asset_id)=>mesh_asset_id,
+					None=>{
+						recoverable_errors.meshpart_content.push(InstancePath::new(dom,object));
+						// Return an empty string which will fail to parse as an asset id
+						""
+					}
 				};
-				match availability{
-					MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
-					MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
-						render,
-						model:model_deferred_attributes
-					}),
-					MeshAvailability::DeferredUnion(part_texture_description)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
-						render:part_texture_description,
-						model:model_deferred_attributes,
-					}),
+				let texture_asset_id=get_content_url(texture_content);
+				(
+					MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(texture_asset_id)),
+					mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id)),
+				)
+			},
+			Shape::PhysicsData=>{
+				let mut content="";
+				let mut mesh_data:&[u8]=&[];
+				let mut physics_data:&[u8]=&[];
+				if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(&static_ustr("AssetId")){
+					content=asset_id.as_ref();
 				}
+				if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("MeshData")){
+					mesh_data=data.as_ref();
+				}
+				if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("PhysicsData")){
+					physics_data=data.as_ref();
+				}
+				let part_texture_description=get_texture_description(render_config_deferred_loader,&mut recoverable_errors,db,dom,object,size);
+				let mesh_index=MeshIndex::union(content,mesh_data,physics_data,size,part_texture_description.clone());
+				let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
+				(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
+			},
+		};
+		let velocity=match vec3::try_from_f32_array([velocity.x,velocity.y,velocity.z]){
+			Ok(velocity)=>velocity,
+			Err(e)=>{
+				recoverable_errors.basepart_velocity.push(Planar64ConvertError{
+					path:InstancePath::new(dom,object),
+					error:e,
+				});
+				continue;
 			}
+		};
+		let model_deferred_attributes=ModelDeferredAttributes{
+			mesh:mesh_id,
+			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(),
+				can_collide,
+				velocity,
+			},
+		};
+		match availability{
+			MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
+			MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
+				render,
+				model:model_deferred_attributes
+			}),
+			MeshAvailability::DeferredUnion(part_texture_description)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
+				render:part_texture_description,
+				model:model_deferred_attributes,
+			}),
 		}
 	}
 	PartialMap1{
@@ -707,25 +759,26 @@ pub fn convert<'a>(
 		primitive_models_deferred_attributes,
 		deferred_models_deferred_attributes,
 		deferred_unions_deferred_attributes,
+		recoverable_errors,
 	}
 }
-struct MeshWithAabb{
-	mesh:model::Mesh,
-	aabb:Aabb,
+struct MeshIdWithSize{
+	mesh:model::MeshId,
+	size:Planar64Vec3,
 }
 fn acquire_mesh_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	mesh_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RenderConfigId,model::MeshId>>,
-	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_mesh_id:model::MeshId,
 	render:RenderConfigId,
-)->Option<(model::MeshId,&'a Aabb)>{
+)->Option<MeshIdWithSize>{
 	//ignore meshes that fail to load completely for now
-	loaded_meshes.get(&old_mesh_id).map(|mesh_with_aabb|(
-		*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
+	loaded_meshes.get(&old_mesh_id).map(|&MeshWithSize{ref mesh,size}|MeshIdWithSize{
+		mesh:*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
 		.entry(render).or_insert_with(||{
 			let mesh_id=model::MeshId::new(primitive_meshes.len() as u32);
-			let mut mesh_clone=mesh_with_aabb.mesh.clone();
+			let mut mesh_clone=mesh.clone();
 			//set the render group lool
 			if let Some(graphics_group)=mesh_clone.graphics_groups.first_mut(){
 				graphics_group.render=render;
@@ -733,22 +786,22 @@ fn acquire_mesh_id_from_render_config_id<'a>(
 			primitive_meshes.push(mesh_clone);
 			mesh_id
 		}),
-		&mesh_with_aabb.aabb,
-	))
+		size,
+	})
 }
 fn acquire_union_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	union_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RobloxPartDescription,model::MeshId>>,
-	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_union_id:model::MeshId,
 	part_texture_description:RobloxPartDescription,
-)->Option<(model::MeshId,&'a Aabb)>{
+)->Option<MeshIdWithSize>{
 	//ignore uniones that fail to load completely for now
-	loaded_meshes.get(&old_union_id).map(|union_with_aabb|(
-		*union_id_from_render_config_id.entry(old_union_id).or_insert_with(||HashMap::new())
+	loaded_meshes.get(&old_union_id).map(|&MeshWithSize{ref mesh,size}|MeshIdWithSize{
+		mesh:*union_id_from_render_config_id.entry(old_union_id).or_insert_with(||HashMap::new())
 		.entry(part_texture_description.clone()).or_insert_with(||{
 			let union_id=model::MeshId::new(primitive_meshes.len() as u32);
-			let mut union_clone=union_with_aabb.mesh.clone();
+			let mut union_clone=mesh.clone();
 			//set the render groups
 			for (graphics_group,maybe_face_texture_description) in union_clone.graphics_groups.iter_mut().zip(part_texture_description.0){
 				if let Some(face_texture_description)=maybe_face_texture_description{
@@ -758,19 +811,20 @@ fn acquire_union_id_from_render_config_id<'a>(
 			primitive_meshes.push(union_clone);
 			union_id
 		}),
-		&union_with_aabb.aabb,
-	))
+		size,
+	})
 }
 pub struct PartialMap1<'a>{
 	primitive_meshes:Vec<model::Mesh>,
 	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes<'a>>,
 	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes<'a>>,
 	deferred_unions_deferred_attributes:Vec<DeferredUnionDeferredAttributes<'a>>,
+	recoverable_errors:RecoverableErrors,
 }
 impl PartialMap1<'_>{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
 		mut self,
-		meshpart_meshes:Meshes,
+		meshpart_meshes:Meshes<MeshWithSize>,
 	)->PartialMap2{
 		//calculate attributes
 		let mut modes_builder=ModesBuilder::default();
@@ -782,22 +836,14 @@ impl PartialMap1<'_>{
 
 		//decode roblox meshes
 		//generate mesh_id_map based on meshes that failed to load
-		let loaded_meshes:HashMap<model::MeshId,MeshWithAabb>=
-		meshpart_meshes.consume().map(|(old_mesh_id,mesh)|{
-			let mut aabb=strafesnet_common::aabb::Aabb::default();
-			for &pos in &mesh.unique_pos{
-				aabb.grow(pos);
-			}
-			(old_mesh_id,MeshWithAabb{
-				mesh,
-				aabb,
-			})
-		}).collect();
+		let loaded_meshes:HashMap<model::MeshId,MeshWithSize>=
+		meshpart_meshes.consume().collect();
 
 		// SAFETY: I have no idea what I'm doing and this is definitely unsound in some subtle way
 		// I just want to chain iterators together man
 		let aint_no_way=core::cell::UnsafeCell::new(&mut self.primitive_meshes);
 
+		let mut model_counter=0;
 		let mut mesh_id_from_render_config_id=HashMap::new();
 		let mut union_id_from_render_config_id=HashMap::new();
 		//now that the meshes are loaded, these models can be generated
@@ -805,23 +851,22 @@ impl PartialMap1<'_>{
 		self.deferred_models_deferred_attributes.into_iter().flat_map(|deferred_model_deferred_attributes|{
 			//meshes need to be cloned from loaded_meshes with a new id when they are used with a new render_id
 			//insert into primitive_meshes
-			let (mesh,aabb)=acquire_mesh_id_from_render_config_id(
+			let MeshIdWithSize{mesh,size:mesh_size}=acquire_mesh_id_from_render_config_id(
 				unsafe{*aint_no_way.get()},
 				&mut mesh_id_from_render_config_id,
 				&loaded_meshes,
 				deferred_model_deferred_attributes.model.mesh,
 				deferred_model_deferred_attributes.render
 			)?;
-			let size=aabb.size();
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_model_deferred_attributes.model.deferred_attributes,
 				color:deferred_model_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/mesh_size.x).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/mesh_size.y).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/mesh_size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_model_deferred_attributes.model.transform.translation
 				),
@@ -829,14 +874,13 @@ impl PartialMap1<'_>{
 		}).chain(self.deferred_unions_deferred_attributes.into_iter().flat_map(|deferred_union_deferred_attributes|{
 			//meshes need to be cloned from loaded_meshes with a new id when they are used with a new render_id
 			//insert into primitive_meshes
-			let (mesh,aabb)=acquire_union_id_from_render_config_id(
+			let MeshIdWithSize{mesh,size}=acquire_union_id_from_render_config_id(
 				unsafe{*aint_no_way.get()},
 				&mut union_id_from_render_config_id,
 				&loaded_meshes,
 				deferred_union_deferred_attributes.model.mesh,
 				deferred_union_deferred_attributes.render
 			)?;
-			let size=aabb.size();
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_union_deferred_attributes.model.deferred_attributes,
@@ -852,61 +896,78 @@ impl PartialMap1<'_>{
 			})
 		}))
 		.chain(self.primitive_models_deferred_attributes.into_iter())
-		.enumerate().map(|(model_id,model_deferred_attributes)|{
-			let model_id=model::ModelId::new(model_id as u32);
-			ModelOwnedAttributes{
+		.filter_map(|model_deferred_attributes|{
+			let model_id=model::ModelId::new(model_counter);
+			let attributes=match get_attributes(
+				&model_deferred_attributes.deferred_attributes.name,
+				model_deferred_attributes.deferred_attributes.can_collide,
+				model_deferred_attributes.deferred_attributes.velocity,
+				model_id,
+				&mut modes_builder,
+				&mut wormhole_in_model_to_id,
+				&mut wormhole_id_to_out_model,
+			){
+				Ok(attributes)=>attributes,
+				Err(e)=>{
+					match e{
+						GetAttributesError::ModeIdParseInt(e)=>self.recoverable_errors.mode_id_parse_int.push(e),
+						GetAttributesError::DuplicateMode(mode_id)=>{self.recoverable_errors.duplicate_mode.insert(mode_id);},
+						GetAttributesError::StageIdParseInt(e)=>self.recoverable_errors.stage_id_parse_int.push(e),
+						GetAttributesError::DuplicateStage(duplicate_stage)=>{self.recoverable_errors.duplicate_stage.insert(duplicate_stage);},
+						GetAttributesError::WormholeOutIdParseInt(e)=>self.recoverable_errors.wormhole_out_id_parse_int.push(e),
+						GetAttributesError::DuplicateWormholeOut(wormhole_id)=>{self.recoverable_errors.duplicate_wormhole_out.insert(wormhole_id);},
+						GetAttributesError::WormholeInIdParseInt(e)=>self.recoverable_errors.wormhole_in_id_parse_int.push(e),
+						GetAttributesError::JumpLimitParseInt(e)=>self.recoverable_errors.jump_limit_parse_int.push(e),
+					}
+					return None;
+				}
+			};
+			model_counter+=1;
+			Some(ModelOwnedAttributes{
 				mesh:model_deferred_attributes.mesh,
-				attributes:get_attributes(
-					&model_deferred_attributes.deferred_attributes.name,
-					model_deferred_attributes.deferred_attributes.can_collide,
-					model_deferred_attributes.deferred_attributes.velocity,
-					model_id,
-					&mut modes_builder,
-					&mut wormhole_in_model_to_id,
-					&mut wormhole_id_to_out_model,
-				),
+				attributes,
 				color:model_deferred_attributes.color,
 				transform:model_deferred_attributes.transform,
-			}
+			})
 		}).collect();
 		let models=models_owned_attributes.into_iter().enumerate().map(|(model_id,mut model_owned_attributes)|{
-		//TODO: TAB
-		let model_id=model::ModelId::new(model_id as u32);
-		//update attributes with wormhole id
-		//TODO: errors/prints
-		if let Some(wormhole_id)=wormhole_in_model_to_id.get(&model_id){
-			if let Some(&wormhole_out_model_id)=wormhole_id_to_out_model.get(wormhole_id){
-				match &mut model_owned_attributes.attributes{
-					attr::CollisionAttributes::Contact(attr::ContactAttributes{contacting:_,general})
-					|attr::CollisionAttributes::Intersect(attr::IntersectAttributes{intersecting:_,general})
-					=>general.wormhole=Some(attr::Wormhole{destination_model:wormhole_out_model_id}),
-					attr::CollisionAttributes::Decoration=>println!("Not a wormhole"),
+			let model_id=model::ModelId::new(model_id as u32);
+			//update attributes with wormhole id
+			//TODO: errors/prints
+			if let Some(wormhole_id)=wormhole_in_model_to_id.get(&model_id){
+				if let Some(&wormhole_out_model_id)=wormhole_id_to_out_model.get(wormhole_id){
+					match &mut model_owned_attributes.attributes{
+						attr::CollisionAttributes::Contact(attr::ContactAttributes{contacting:_,general})
+						|attr::CollisionAttributes::Intersect(attr::IntersectAttributes{intersecting:_,general})
+						=>general.wormhole=Some(attr::Wormhole{destination_model:wormhole_out_model_id}),
+						attr::CollisionAttributes::Decoration=>println!("Not a wormhole"),
+					}
 				}
 			}
-		}
 
-		//index the attributes
-		let attributes_id=if let Some(&attributes_id)=attributes_id_from_attributes.get(&model_owned_attributes.attributes){
-			attributes_id
-		}else{
-			let attributes_id=attr::CollisionAttributesId::new(unique_attributes.len() as u32);
-			attributes_id_from_attributes.insert(model_owned_attributes.attributes.clone(),attributes_id);
-			unique_attributes.push(model_owned_attributes.attributes);
-			attributes_id
-		};
-		model::Model{
-			mesh:model_owned_attributes.mesh,
-			transform:model_owned_attributes.transform,
-			color:model_owned_attributes.color,
-			attributes:attributes_id,
+			//index the attributes
+			let attributes_id=if let Some(&attributes_id)=attributes_id_from_attributes.get(&model_owned_attributes.attributes){
+				attributes_id
+			}else{
+				let attributes_id=attr::CollisionAttributesId::new(unique_attributes.len() as u32);
+				attributes_id_from_attributes.insert(model_owned_attributes.attributes.clone(),attributes_id);
+				unique_attributes.push(model_owned_attributes.attributes);
+				attributes_id
+			};
+			model::Model{
+				mesh:model_owned_attributes.mesh,
+				transform:model_owned_attributes.transform,
+				color:model_owned_attributes.color,
+				attributes:attributes_id,
+			}
+		}).collect();
+		PartialMap2{
+			meshes:self.primitive_meshes,
+			models,
+			modes:modes_builder.build_normalized(),
+			attributes:unique_attributes,
+			recoverable_errors:self.recoverable_errors,
 		}
-	}).collect();
-	PartialMap2{
-		meshes:self.primitive_meshes,
-		models,
-		modes:modes_builder.build_normalized(),
-		attributes:unique_attributes,
-	}
 	}
 }
 
@@ -915,12 +976,13 @@ pub struct PartialMap2{
 	models:Vec<model::Model>,
 	modes:NormalizedModes,
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+	recoverable_errors:RecoverableErrors,
 }
 impl PartialMap2{
 	pub fn add_render_configs_and_textures(
 		self,
 		render_configs:RenderConfigs,
-	)->map::CompleteMap{
+	)->(map::CompleteMap,RecoverableErrors){
 		let (textures,render_configs)=render_configs.consume();
 		let (textures,texture_id_map):(Vec<Vec<u8>>,HashMap<model::TextureId,model::TextureId>)
 		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,Texture::ImageDDS(texture)))|{
@@ -939,14 +1001,17 @@ impl PartialMap2{
 			);
 			render_config
 		}).collect();
-		map::CompleteMap{
-			modes:self.modes,
-			attributes:self.attributes,
-			meshes:self.meshes,
-			models:self.models,
-			//the roblox legacy texture thing always works
-			textures,
-			render_configs,
-		}
+		(
+			map::CompleteMap{
+				modes:self.modes,
+				attributes:self.attributes,
+				meshes:self.meshes,
+				models:self.models,
+				//the roblox legacy texture thing always works
+				textures,
+				render_configs,
+			},
+			self.recoverable_errors,
+		)
 	}
 }

lib/rbx_loader/src/union.rs

@@ -1,9 +1,12 @@
-use rbx_mesh::mesh_data::{NormalId2 as MeshDataNormalId2,VertexId as MeshDataVertexId};
+use crate::loader::MeshWithSize;
+use crate::rbx::RobloxPartDescription;
+use crate::primitives::{CUBE_DEFAULT_VERTICES,CUBE_DEFAULT_POLYS,FaceDescription};
+
+use rbx_mesh::mesh_data::{VertexId as MeshDataVertexId,NormalId as MeshDataNormalId,NormalId2 as MeshDataNormalId2,NormalId5 as MeshDataNormalId5};
 use rbx_mesh::physics_data::VertexId as PhysicsDataVertexId;
-use strafesnet_common::model::{self,IndexedVertex,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId};
+use strafesnet_common::model::{self,IndexedVertex,MeshBuilder,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId,VertexId};
 use strafesnet_common::integer::vec3;
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Block,
@@ -21,7 +24,7 @@ impl std::fmt::Display for Error{
 // wacky state machine to make sure all vertices in a face agree upon what NormalId to use.
 // Roblox duplicates this information per vertex when it should only exist per-face.
 enum MeshDataNormalStatus{
-	Agree(MeshDataNormalId2),
+	Agree(MeshDataNormalId),
 	Conflicting,
 }
 struct MeshDataNormalChecker{
@@ -31,7 +34,7 @@ impl MeshDataNormalChecker{
 	fn new()->Self{
 		Self{status:None}
 	}
-	fn check(&mut self,normal:MeshDataNormalId2){
+	fn check(&mut self,normal:MeshDataNormalId){
 		self.status=match self.status.take(){
 			None=>Some(MeshDataNormalStatus::Agree(normal)),
 			Some(MeshDataNormalStatus::Agree(old_normal))=>{
@@ -44,7 +47,7 @@ impl MeshDataNormalChecker{
 			Some(MeshDataNormalStatus::Conflicting)=>Some(MeshDataNormalStatus::Conflicting),
 		};
 	}
-	fn into_agreed_normal(self)->Option<MeshDataNormalId2>{
+	fn into_agreed_normal(self)->Option<MeshDataNormalId>{
 		self.status.and_then(|status|match status{
 			MeshDataNormalStatus::Agree(normal)=>Some(normal),
 			MeshDataNormalStatus::Conflicting=>None,
@@ -52,18 +55,127 @@ impl MeshDataNormalChecker{
 	}
 }
 
+fn build_mesh2(
+	mb:&mut MeshBuilder,
+	polygon_groups_normal_id:&mut [Vec<Vec<VertexId>>;NORMAL_FACES],
+	cube_face_description:&[Option<FaceDescription>;NORMAL_FACES],
+	mesh:rbx_mesh::mesh_data::Mesh2,
+)->Result<(),Error>{
+	//autoscale to size, idk what roblox is doing with the graphics mesh size
+	let mut pos_min=glam::Vec3::MAX;
+	let mut pos_max=glam::Vec3::MIN;
+	for vertex in &mesh.vertices{
+		let p=vertex.pos.into();
+		pos_min=pos_min.min(p);
+		pos_max=pos_max.max(p);
+	}
+	let graphics_size=pos_max-pos_min;
+	for [MeshDataVertexId(vertex_id0),MeshDataVertexId(vertex_id1),MeshDataVertexId(vertex_id2)] in mesh.faces{
+		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))?,
+		];
+		let mut normal_agreement_checker=MeshDataNormalChecker::new();
+		let face=face.into_iter().map(|vertex|{
+			let MeshDataNormalId2(normal_id)=vertex.normal_id;
+			normal_agreement_checker.check(normal_id);
+			let pos=glam::Vec3::from_array(vertex.pos)/graphics_size;
+			let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array())?);
+			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?);
+			let tex_coord=glam::Vec2::from_array(vertex.tex);
+			let maybe_face_description=&cube_face_description[normal_id as usize-1];
+			let (tex,color)=match maybe_face_description{
+				Some(face_description)=>{
+					// transform texture coordinates and set decal color
+					let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
+					let color=mb.acquire_color_id(face_description.color);
+					(tex,color)
+				},
+				None=>{
+					// texture coordinates don't matter and pass through mesh vertex color
+					let tex=mb.acquire_tex_id(tex_coord);
+					let color=mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)));
+					(tex,color)
+				},
+			};
+			Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+		}).collect::<Result<Vec<_>,_>>().map_err(Error::Planar64Vec3)?;
+		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
+			polygon_groups_normal_id[normal_id as usize-1].push(face);
+		}else{
+			panic!("Empty face!");
+		}
+	}
+	Ok(())
+}
+fn build_mesh5(
+	mb:&mut MeshBuilder,
+	polygon_groups_normal_id:&mut [Vec<Vec<VertexId>>;NORMAL_FACES],
+	cube_face_description:&[Option<FaceDescription>;NORMAL_FACES],
+	mesh:rbx_mesh::mesh_data::CSGMDL5,
+)->Result<(),Error>{
+	//autoscale to size, idk what roblox is doing with the graphics mesh size
+	let mut pos_min=glam::Vec3::MAX;
+	let mut pos_max=glam::Vec3::MIN;
+	for &pos in &mesh.positions{
+		let p=pos.into();
+		pos_min=pos_min.min(p);
+		pos_max=pos_max.max(p);
+	}
+	let graphics_size=pos_max-pos_min;
+	for face in mesh.faces.indices.chunks_exact(3){
+		let mut normal_agreement_checker=MeshDataNormalChecker::new();
+		let face=face.into_iter().map(|&vertex_id|{
+			let vertex_index=vertex_id as usize;
+			let &pos=mesh.positions.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &MeshDataNormalId5(normal_id)=mesh.normal_ids.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &norm=mesh.normals.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &tex=mesh.tex.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			let &color=mesh.colors.get(vertex_index).ok_or(Error::MissingVertexId(vertex_id))?;
+			normal_agreement_checker.check(normal_id);
+			let pos=glam::Vec3::from_array(pos)/graphics_size;
+			let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array()).map_err(Error::Planar64Vec3)?);
+			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(norm).map_err(Error::Planar64Vec3)?);
+			let tex_coord=glam::Vec2::from_array(tex);
+			let maybe_face_description=&cube_face_description[normal_id as usize-1];
+			let (tex,color)=match maybe_face_description{
+				Some(face_description)=>{
+					// transform texture coordinates and set decal color
+					let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
+					let color=mb.acquire_color_id(face_description.color);
+					(tex,color)
+				},
+				None=>{
+					// texture coordinates don't matter and pass through mesh vertex color
+					let tex=mb.acquire_tex_id(tex_coord);
+					let color=mb.acquire_color_id(glam::Vec4::from_array(color.map(|f|f as f32/255.0f32)));
+					(tex,color)
+				},
+			};
+			Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+		}).collect::<Result<Vec<_>,_>>()?;
+		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
+			polygon_groups_normal_id[normal_id as usize-1].push(face);
+		}else{
+			panic!("Empty face!");
+		}
+	}
+	Ok(())
+}
+
+const NORMAL_FACES:usize=6;
 impl std::error::Error for Error{}
 pub fn convert(
 	roblox_physics_data:&[u8],
 	roblox_mesh_data:&[u8],
 	size:glam::Vec3,
-	crate::rbx::RobloxPartDescription(part_texture_description):crate::rbx::RobloxPartDescription,
-)->Result<model::Mesh,Error>{
-	const NORMAL_FACES:usize=6;
-	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
+	RobloxPartDescription(part_texture_description):RobloxPartDescription,
+)->Result<MeshWithSize,Error>{
+	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();
+	let mut mb=MeshBuilder::new();
 	// graphics
 	let graphics_groups=if !roblox_mesh_data.is_empty(){
 		// create per-face texture coordinate affine transforms
@@ -75,46 +187,12 @@ pub fn convert(
 		let mesh_data=rbx_mesh::read_mesh_data_versioned(
 			std::io::Cursor::new(roblox_mesh_data)
 		).map_err(Error::RobloxMeshData)?;
-		let graphics_mesh=match mesh_data{
+		match mesh_data{
 			rbx_mesh::mesh_data::MeshData::CSGK(_)=>return Err(Error::Block),
-			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL2(mesh_data2))=>mesh_data2.mesh,
-			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL4(mesh_data4))=>mesh_data4.mesh,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::V2(mesh_data2))=>build_mesh2(&mut mb,&mut polygon_groups_normal_id,&cube_face_description,mesh_data2.mesh)?,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::V4(mesh_data4))=>build_mesh2(&mut mb,&mut polygon_groups_normal_id,&cube_face_description,mesh_data4.mesh)?,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::V5(mesh_data4))=>build_mesh5(&mut mb,&mut polygon_groups_normal_id,&cube_face_description,mesh_data4)?,
 		};
-		for [MeshDataVertexId(vertex_id0),MeshDataVertexId(vertex_id1),MeshDataVertexId(vertex_id2)] in graphics_mesh.faces{
-			let face=[
-				graphics_mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
-				graphics_mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
-				graphics_mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
-			];
-			let mut normal_agreement_checker=MeshDataNormalChecker::new();
-			let face=face.into_iter().map(|vertex|{
-				normal_agreement_checker.check(vertex.normal_id);
-				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?);
-				let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?);
-				let tex_coord=glam::Vec2::from_array(vertex.tex);
-				let maybe_face_description=&cube_face_description[vertex.normal_id as usize-1];
-				let (tex,color)=match maybe_face_description{
-					Some(face_description)=>{
-						// transform texture coordinates and set decal color
-						let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
-						let color=mb.acquire_color_id(face_description.color);
-						(tex,color)
-					},
-					None=>{
-						// texture coordinates don't matter and pass through mesh vertex color
-						let tex=mb.acquire_tex_id(tex_coord);
-						let color=mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)));
-						(tex,color)
-					},
-				};
-				Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
-			}).collect::<Result<Vec<_>,_>>().map_err(Error::Planar64Vec3)?;
-			if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
-				polygon_groups_normal_id[normal_id as usize-1].push(face);
-			}else{
-				panic!("Empty face!");
-			}
-		}
 		(0..NORMAL_FACES).map(|polygon_group_id|{
 			model::IndexedGraphicsGroup{
 				render:cube_face_description[polygon_group_id].as_ref().map_or(RenderConfigId::new(0),|face_description|face_description.render),
@@ -126,7 +204,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)?;
@@ -135,44 +217,56 @@ pub fn convert(
 			// have not seen this format in practice
 			|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Block)
 			=>return Err(Error::Block),
-			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes(meshes))
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V3(meshes))
+			|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V5(meshes))
+			=>meshes.meshes,
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V6(meshes))
+			=>vec![meshes.mesh],
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::V7(meshes))
 			=>meshes.meshes,
-			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 unit cube as default physics
+		let pos_list=CUBE_DEFAULT_VERTICES.map(|pos|mb.acquire_pos_id(pos>>1));
 		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();
-	Ok(mb.build(
+	let mesh=mb.build(
 		polygon_groups,
 		graphics_groups,
 		physics_groups,
-	))
+	);
+	Ok(MeshWithSize{
+		mesh,
+		size:vec3::ONE,
+	})
 }

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -14,7 +14,7 @@ run-service=[]
 [dependencies]
 glam = "0.30.0"
 mlua = { version = "0.10.1", features = ["luau"] }
-phf = { version = "0.11.2", features = ["macros"] }
+phf = { version = "0.12.1", features = ["macros"] }
 rbx_dom_weak = { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
 rbx_reflection = "5.0.0"
 rbx_reflection_database = "1.0.0"

lib/roblox_emulator/src/context.rs

@@ -79,7 +79,15 @@ impl Context{
 
 		//insert services
 		let game=dom.root_ref();
-		let terrain_bldr=InstanceBuilder::new("Terrain");
+		let terrain_bldr=InstanceBuilder::new("Terrain")
+		.with_properties([
+			("CFrame",rbx_dom_weak::types::Variant::CFrame(rbx_dom_weak::types::CFrame::new(rbx_dom_weak::types::Vector3::new(0.0,0.0,0.0),rbx_dom_weak::types::Matrix3::identity()))),
+			("Size",rbx_dom_weak::types::Variant::Vector3(rbx_dom_weak::types::Vector3::new(1.0,1.0,1.0))),
+			("Velocity",rbx_dom_weak::types::Variant::Vector3(rbx_dom_weak::types::Vector3::new(0.0,0.0,0.0))),
+			("Transparency",rbx_dom_weak::types::Variant::Float32(0.0)),
+			("Color",rbx_dom_weak::types::Variant::Color3uint8(rbx_dom_weak::types::Color3uint8::new(255,255,255))),
+			("CanCollide",rbx_dom_weak::types::Variant::Bool(true)),
+		]);
 		let workspace=dom.insert(game,
 			InstanceBuilder::new("Workspace")
 				//Set Workspace.Terrain property equal to Terrain

lib/roblox_emulator/src/runner/instance/instance.rs

@@ -519,7 +519,7 @@ struct ClassMethodsStore{
 }
 impl ClassMethodsStore{
 	/// return self.classes[class] or create the ClassMethods and then return it
-	fn get_or_create_class_methods(&mut self,class:&str)->Option<ClassMethods>{
+	fn get_or_create_class_methods(&mut self,class:&str)->Option<ClassMethods<'_>>{
 		// Use get_entry to get the &'static str keys of the database
 		// and use it as a key for the classes hashmap
 		CLASS_FUNCTION_DATABASE.get_entry(class)

lib/roblox_emulator/src/runner/runner.rs

@@ -13,14 +13,12 @@ pub enum Error{
 		error:mlua::Error
 	},
 	RustLua(mlua::Error),
-	Services(crate::context::ServicesError),
 }
 impl std::fmt::Display for Error{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		match self{
 			Self::Lua{source,error}=>write!(f,"lua error: source:\n{source}\n{error}"),
 			Self::RustLua(error)=>write!(f,"rust-side lua error: {error}"),
-			other=>write!(f,"{other:?}"),
 		}
 	}
 }

lib/roblox_emulator/src/runner/tween.rs

@@ -1,7 +1,7 @@
 use super::instance::Instance;
 use super::tween_info::TweenInfo;
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Clone)]
 pub struct Tween{
 	instance:Instance,

lib/roblox_emulator/src/runner/tween_info.rs

@@ -1,7 +1,7 @@
 use super::number::Number;
 use super::r#enum::{CoerceEnum,Enums};
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Clone)]
 pub struct TweenInfo{
 	time:f64,

lib/snf/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "strafesnet_snf"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-binrw = "0.14.0"
+binrw = "0.15.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }

lib/snf/src/bot.rs

@@ -85,6 +85,7 @@ pub struct Segment{
 #[derive(Clone,Copy,Debug)]
 pub struct SegmentInfo{
 	/// time of the first instruction in this segment.
+	#[expect(dead_code)]
 	time:Time,
 	instruction_count:u32,
 	/// How many total instructions in segments up to and including this segment
@@ -116,6 +117,7 @@ impl<R:BinReaderExt> StreamableBot<R>{
 			segment_map,
 		})
 	}
+	#[expect(dead_code)]
 	fn get_segment_info(&self,segment_id:SegmentId)->Result<SegmentInfo,Error>{
 		Ok(*self.segment_map.get(segment_id.get() as usize).ok_or(Error::InvalidSegmentId(segment_id))?)
 	}

lib/snf/src/file.rs

@@ -53,8 +53,6 @@ pub(crate) enum FourCC{
 	Map,
 	#[brw(magic=b"SNFB")]
 	Bot,
-	#[brw(magic=b"SNFD")]
-	Demo,
 }
 #[binrw]
 #[brw(little)]

lib/snf/src/lib.rs

@@ -5,7 +5,6 @@ mod newtypes;
 mod file;
 pub mod map;
 pub mod bot;
-pub mod demo;
 
 #[derive(Debug)]
 pub enum Error{
@@ -13,7 +12,6 @@ pub enum Error{
 	Header(file::Error),
 	Map(map::Error),
 	Bot(bot::Error),
-	Demo(demo::Error),
 }
 impl std::fmt::Display for Error{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -25,7 +23,6 @@ impl std::error::Error for Error{}
 pub enum SNF<R:BinReaderExt>{
 	Map(map::StreamableMap<R>),
 	Bot(bot::StreamableBot<R>),
-	Demo(demo::StreamableDemo<R>),
 }
 
 pub fn read_snf<R:BinReaderExt>(input:R)->Result<SNF<R>,Error>{
@@ -33,7 +30,6 @@ pub fn read_snf<R:BinReaderExt>(input:R)->Result<SNF<R>,Error>{
 	Ok(match file.fourcc(){
 		file::FourCC::Map=>SNF::Map(map::StreamableMap::new(file).map_err(Error::Map)?),
 		file::FourCC::Bot=>SNF::Bot(bot::StreamableBot::new(file).map_err(Error::Bot)?),
-		file::FourCC::Demo=>SNF::Demo(demo::StreamableDemo::new(file).map_err(Error::Demo)?),
 	})
 }
 pub fn read_map<R:BinReaderExt>(input:R)->Result<map::StreamableMap<R>,Error>{
@@ -50,13 +46,6 @@ pub fn read_bot<R:BinReaderExt>(input:R)->Result<bot::StreamableBot<R>,Error>{
 		_=>Err(Error::UnexpectedFourCC)
 	}
 }
-pub fn read_demo<R:BinReaderExt>(input:R)->Result<demo::StreamableDemo<R>,Error>{
-	let file=file::File::new(input).map_err(Error::Header)?;
-	match file.fourcc(){
-		file::FourCC::Demo=>Ok(demo::StreamableDemo::new(file).map_err(Error::Demo)?),
-		_=>Err(Error::UnexpectedFourCC)
-	}
-}
 
 #[cfg(test)]
 mod tests {

lib/snf/src/newtypes/gameplay_style.rs

@@ -104,6 +104,7 @@ impl From<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 
 #[binrw::binrw]
 #[brw(little,repr=u8)]
+#[expect(dead_code)]
 pub enum JumpCalculation{
 	Max,
 	BoostThenJump,
@@ -128,6 +129,7 @@ impl From<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculatio
 	}
 }
 
+#[expect(dead_code)]
 pub enum JumpImpulse{
 	Time(Time),
 	Height(Planar64),

map-tool/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "map-tool"
-version = "1.7.0"
+version = "1.7.2"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -19,10 +19,10 @@ rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet" }
 rbx_reflection_database = "1.0.0"
 rbx_xml = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_bsp_loader = { version = "0.3.0", path = "../lib/bsp_loader", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.0", path = "../lib/deferred_loader", registry = "strafesnet" }
-strafesnet_rbx_loader = { version = "0.6.0", path = "../lib/rbx_loader", registry = "strafesnet" }
-strafesnet_snf = { version = "0.3.0", path = "../lib/snf", registry = "strafesnet" }
+strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
+strafesnet_rbx_loader = { version = "0.7.0", path = "../lib/rbx_loader", registry = "strafesnet" }
+strafesnet_snf = { version = "0.3.1", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
 vbsp = "0.9.1"

map-tool/src/roblox.rs

@@ -32,8 +32,12 @@ pub struct RobloxToSNFSubcommand {
 pub struct DownloadAssetsSubcommand{
 	#[arg(required=true)]
 	roblox_files:Vec<PathBuf>,
-	// #[arg(long)]
-	// cookie_file:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
 }
 
 impl Commands{
@@ -42,13 +46,27 @@ impl Commands{
 			Commands::RobloxToSNF(subcommand)=>roblox_to_snf(subcommand.input_files,subcommand.output_folder).await,
 			Commands::DownloadAssets(subcommand)=>download_assets(
 				subcommand.roblox_files,
-				rbx_asset::cookie::Cookie::new("".to_string()),
+				cookie_from_args(
+					subcommand.cookie_literal,
+					subcommand.cookie_envvar,
+					subcommand.cookie_file,
+				).await?,
 			).await,
 		}
 	}
 }
 
-#[allow(unused)]
+async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<rbx_asset::cookie::Cookie>{
+	let cookie=match (literal,environment,file){
+		(Some(cookie_literal),None,None)=>cookie_literal,
+		(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
+		(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
+		_=>Err(anyhow::Error::msg("Illegal cookie argument triple"))?,
+	};
+	Ok(rbx_asset::cookie::Cookie::new(cookie))
+}
+
+#[expect(dead_code)]
 #[derive(Debug)]
 enum LoadDomError{
 	IO(std::io::Error),
@@ -174,7 +192,7 @@ impl UniqueAssets{
 	}
 }
 
-#[allow(unused)]
+#[expect(dead_code)]
 #[derive(Debug)]
 enum UniqueAssetError{
 	IO(std::io::Error),
@@ -249,8 +267,8 @@ async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,dow
 				tokio::fs::write(path,&data).await?;
 				break Ok(DownloadResult::Data(data));
 			},
-			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::StatusCodeWithUrlAndBody(scwuab)))=>{
-				if scwuab.status_code.as_u16()==429{
+			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::Details{status_code,url_and_body}))=>{
+				if status_code.as_u16()==429{
 					if retry==12{
 						println!("Giving up asset download {asset_id}");
 						stats.timed_out_downloads+=1;
@@ -262,7 +280,7 @@ async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,dow
 					retry+=1;
 				}else{
 					stats.failed_downloads+=1;
-					println!("weird scuwab error: {scwuab:?}");
+					println!("weird status_code error: status_code={status_code} url={} body={}",url_and_body.url,url_and_body.body);
 					break Ok(DownloadResult::Failed);
 				}
 			},
@@ -403,7 +421,7 @@ async fn download_assets(paths:Vec<PathBuf>,cookie:rbx_asset::cookie::Cookie)->A
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum ConvertError{
 	IO(std::io::Error),
 	SNFMap(strafesnet_snf::map::Error),
@@ -416,17 +434,23 @@ impl std::fmt::Display for ConvertError{
 	}
 }
 impl std::error::Error for ConvertError{}
-async fn convert_to_snf(path:&Path,output_folder:PathBuf)->AResult<()>{
-	let entire_file=tokio::fs::read(path).await?;
+
+struct Errors{
+	script_errors:Vec<strafesnet_rbx_loader::RunnerError>,
+	convert_errors:strafesnet_rbx_loader::RecoverableErrors,
+}
+
+fn convert_to_snf(path:&Path,output_folder:PathBuf)->Result<Errors,ConvertError>{
+	let entire_file=std::fs::read(path).map_err(ConvertError::IO)?;
 
 	let model=strafesnet_rbx_loader::read(
-		std::io::Cursor::new(entire_file)
+		entire_file.as_slice()
 	).map_err(ConvertError::RobloxRead)?;
 
 	let mut place=strafesnet_rbx_loader::Place::from(model);
-	place.run_scripts();
+	let script_errors=place.run_scripts().unwrap_or_else(|e|vec![e]);
 
-	let map=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;
+	let (map,convert_errors)=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;
 
 	let mut dest=output_folder;
 	dest.push(path.file_stem().unwrap());
@@ -435,7 +459,10 @@ async fn convert_to_snf(path:&Path,output_folder:PathBuf)->AResult<()>{
 
 	strafesnet_snf::map::write_map(file,map).map_err(ConvertError::SNFMap)?;
 
-	Ok(())
+	Ok(Errors{
+		script_errors,
+		convert_errors,
+	})
 }
 
 async fn roblox_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf)->AResult<()>{
@@ -444,15 +471,25 @@ async fn roblox_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf)->ARe
 	let thread_limit=std::thread::available_parallelism()?.get();
 	let mut it=paths.into_iter();
 	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+	// This is wrong! Calling roblox_to_snf multiple times keeps adding permits
 	SEM.add_permits(thread_limit);
 
 	while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
 		let output_folder=output_folder.clone();
-		tokio::spawn(async move{
-			let result=convert_to_snf(path.as_path(),output_folder).await;
+		tokio::task::spawn_blocking(move||{
+			let result=convert_to_snf(path.as_path(),output_folder);
 			drop(permit);
 			match result{
-				Ok(())=>(),
+				Ok(errors)=>{
+					for error in errors.script_errors{
+						println!("Script error: {error}");
+					}
+					let error_count=errors.convert_errors.count();
+					if error_count!=0{
+						println!("Error count: {error_count}");
+						println!("Errors: {}",errors.convert_errors);
+					}
+				},
 				Err(e)=>println!("Convert error: {e:?}"),
 			}
 		});

map-tool/src/source.rs

@@ -452,7 +452,7 @@ fn bsp_contents(path:PathBuf)->AResult<()>{
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum ConvertError{
 	IO(std::io::Error),
 	SNFMap(strafesnet_snf::map::Error),

strafe-client/Cargo.toml

@@ -28,5 +28,9 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "25.0.0"
+wgpu = "26.0.1"
 winit = "0.30.7"
+
+[profile.dev]
+strip = false
+opt-level = 3

strafe-client/src/file.rs

@@ -3,7 +3,7 @@ use std::io::Read;
 #[cfg(any(feature="roblox",feature="source"))]
 use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Debug)]
 pub enum ReadError{
 	#[cfg(feature="roblox")]
@@ -63,7 +63,7 @@ pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
 	}
 }
 
-#[allow(dead_code)]
+#[expect(dead_code)]
 #[derive(Debug)]
 pub enum LoadError{
 	ReadError(ReadError),
@@ -98,10 +98,15 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 		#[cfg(feature="roblox")]
 		ReadFormat::Roblox(model)=>{
 			let mut place=strafesnet_rbx_loader::Place::from(model);
-			place.run_scripts();
-			Ok(LoadFormat::Map(
-				place.to_snf(LoadFailureMode::DefaultToNone).map_err(LoadError::LoadRoblox)?
-			))
+			let script_errors=place.run_scripts().unwrap();
+			for error in script_errors{
+				println!("Script error: {error}");
+			}
+			let (map,errors)=place.to_snf(LoadFailureMode::DefaultToNone).map_err(LoadError::LoadRoblox)?;
+			if errors.count()!=0{
+				print!("Errors encountered while loading the map:\n{}",errors);
+			}
+			Ok(LoadFormat::Map(map))
 		},
 		#[cfg(feature="source")]
 		ReadFormat::Source(bsp)=>Ok(LoadFormat::Map(

strafe-client/src/graphics_worker.rs

@@ -21,7 +21,7 @@ WorkerDescription{
 pub fn new(
 	mut graphics:graphics::GraphicsState,
 	mut config:wgpu::SurfaceConfiguration,
-	surface:wgpu::Surface,
+	surface:wgpu::Surface<'_>,
 	device:wgpu::Device,
 	queue:wgpu::Queue,
 )->crate::compat_worker::INWorker<'_,Instruction>{

tools/clarion

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client bhop_maps/5692098704.snfm "$@"