expect two events

Match TouchingState contacts HashMap K,V layout to try to get lucky with compiler optimization.

engine/physics/src/model.rs

@@ -752,7 +752,22 @@ impl MinkowskiMesh<'_>{
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
+			match infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time){
+				// This is the expected case.
+				// We expect to never hit the mesh while setting up for the real crawl
+				// since the algorithm breaks down on the inside of the mesh.
+				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
+				// An exact hit is allowed, it has not crossed the boundary.
+				crate::face_crawler::CrawlResult::Hit(face,ratio)=>match start_time{
+					Bound::Included(_)=>ratio.num.is_zero().then(||FEV::Face(face)),
+					// You are looking for collision events within a range that does not include the start_time.
+					// The boundary is crossed at exactly start_time, so the range is not met.
+					// Therefore, the correct return value is None.
+					Bound::Excluded(_)=>unimplemented!(),
+					// To infinity and beyond!
+					Bound::Unbounded=>None,
+				},
+			}
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{

engine/physics/src/physics.rs

@@ -28,6 +28,7 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
+	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -87,7 +88,7 @@ enum JumpDirection{
 impl JumpDirection{
 	fn direction(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,contact:&ContactCollision)->Planar64Vec3{
 		match self{
-			JumpDirection::FromContactNormal=>contact_normal(models,hitbox_mesh,contact),
+			JumpDirection::FromContactNormal=>contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id),
 			&JumpDirection::Exactly(dir)=>dir,
 		}
 	}
@@ -100,7 +101,6 @@ enum TransientAcceleration{
 		time:Time,
 	},
 	//walk target will never be reached
-	#[expect(dead_code)]
 	Unreachable{
 		acceleration:Planar64Vec3,
 	}
@@ -116,6 +116,10 @@ impl TransientAcceleration{
 	fn with_target_diff(target_diff:Planar64Vec3,accel:Planar64,time:Time)->Self{
 		if target_diff==vec3::ZERO{
 			TransientAcceleration::Reached
+		}else if accel==Planar64::ZERO{
+			TransientAcceleration::Unreachable{
+				acceleration:vec3::ZERO
+			}
 		}else{
 			//normal friction acceleration is clippedAcceleration.dot(normal)*friction
 			TransientAcceleration::Reachable{
@@ -160,7 +164,7 @@ impl ContactMoveState{
 	}
 }
 fn ground_things(walk_settings:&gameplay_style::WalkSettings,contact:&ContactCollision,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->(Planar64Vec3,Planar64Vec3){
-	let normal=contact_normal(models,hitbox_mesh,contact);
+	let normal=contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id);
 	let gravity=touching.base_acceleration(models,style,camera,input_state);
 	let control_dir=style.get_y_control_dir(camera,input_state.controls);
 	let target_velocity=walk_settings.get_walk_target_velocity(control_dir,normal);
@@ -168,7 +172,7 @@ fn ground_things(walk_settings:&gameplay_style::WalkSettings,contact:&ContactCol
 	(gravity,target_velocity_clipped)
 }
 fn ladder_things(ladder_settings:&gameplay_style::LadderSettings,contact:&ContactCollision,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->(Planar64Vec3,Planar64Vec3){
-	let normal=contact_normal(models,hitbox_mesh,contact);
+	let normal=contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id);
 	let gravity=touching.base_acceleration(models,style,camera,input_state);
 	let control_dir=style.get_y_control_dir(camera,input_state.controls);
 	let target_velocity=ladder_settings.get_ladder_target_velocity(control_dir,normal);
@@ -193,7 +197,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<PhysicsModelId>)->TransformedMesh<'_>{
 		let (mesh_id,transform)=match convex_mesh_id.model_id{
 			PhysicsModelId::Contact(model_id)=>{
 				let model=&self.contact_models[&model_id];
@@ -210,25 +214,25 @@ 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<'_>{
-		let model=&self.contact_models[&contact.model_id];
+	fn contact_mesh(&self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->TransformedMesh<'_>{
+		let model=&self.contact_models[&convex_mesh_id.model_id];
 		TransformedMesh::new(
-			self.meshes[&model.mesh_id].submesh_view(contact.submesh_id),
+			self.meshes[&model.mesh_id].submesh_view(convex_mesh_id.submesh_id),
 			&model.transform
 		)
 	}
-	fn intersect_mesh(&self,intersect:&IntersectCollision)->TransformedMesh<'_>{
-		let model=&self.intersect_models[&intersect.model_id];
+	fn intersect_mesh(&self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->TransformedMesh<'_>{
+		let model=&self.intersect_models[&convex_mesh_id.model_id];
 		TransformedMesh::new(
-			self.meshes[&model.mesh_id].submesh_view(intersect.submesh_id),
+			self.meshes[&model.mesh_id].submesh_view(convex_mesh_id.submesh_id),
 			&model.transform
 		)
 	}
 	fn get_model_transform(&self,model_id:ModelId)->Option<&PhysicsMeshTransform>{
 		//ModelId can possibly be a decoration
-		match self.contact_models.get(&ContactModelId::new(model_id.get())){
+		match self.contact_models.get(&model_id.into()){
 			Some(model)=>Some(&model.transform),
-			None=>self.intersect_models.get(&IntersectModelId::new(model_id.get()))
+			None=>self.intersect_models.get(&model_id.into())
 				.map(|model|&model.transform),
 		}
 	}
@@ -611,7 +615,7 @@ impl MoveState{
 			// TODO: unduplicate this code
 			match self.get_walk_state(){
 				// did you stop touching the thing you were walking on?
-				Some(walk_state)=>if !touching.contacts.contains(&walk_state.contact){
+				Some(walk_state)=>if !touching.contacts.contains_key(&walk_state.contact.convex_mesh_id){
 					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
@@ -642,9 +646,9 @@ impl TryFrom<&gameplay_attributes::CollisionAttributes> for PhysicsCollisionAttr
 }
 #[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct ContactAttributesId(u32);
-impl Into<CollisionAttributesId> for ContactAttributesId{
-	fn into(self)->CollisionAttributesId{
-		CollisionAttributesId::new(self.0)
+impl From<ContactAttributesId> for CollisionAttributesId{
+	fn from(value:ContactAttributesId)->CollisionAttributesId{
+		CollisionAttributesId::new(value.0)
 	}
 }
 impl From<CollisionAttributesId> for ContactAttributesId{
@@ -654,9 +658,9 @@ impl From<CollisionAttributesId> for ContactAttributesId{
 }
 #[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct IntersectAttributesId(u32);
-impl Into<CollisionAttributesId> for IntersectAttributesId{
-	fn into(self)->CollisionAttributesId{
-		CollisionAttributesId::new(self.0)
+impl From<IntersectAttributesId> for CollisionAttributesId{
+	fn from(value:IntersectAttributesId)->CollisionAttributesId{
+		CollisionAttributesId::new(value.0)
 	}
 }
 impl From<CollisionAttributesId> for IntersectAttributesId{
@@ -666,16 +670,26 @@ impl From<CollisionAttributesId> for IntersectAttributesId{
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct ContactModelId(u32);
-impl Into<ModelId> for ContactModelId{
-	fn into(self)->ModelId{
-		ModelId::new(self.get())
+impl From<ContactModelId> for ModelId{
+	fn from(value:ContactModelId)->ModelId{
+		ModelId::new(value.get())
+	}
+}
+impl From<ModelId> for ContactModelId{
+	fn from(other: ModelId)->Self{
+		Self::new(other.get())
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct IntersectModelId(u32);
-impl Into<ModelId> for IntersectModelId{
-	fn into(self)->ModelId{
-		ModelId::new(self.get())
+impl From<IntersectModelId> for ModelId{
+	fn from(value:IntersectModelId)->ModelId{
+		ModelId::new(value.get())
+	}
+}
+impl From<ModelId> for IntersectModelId{
+	fn from(other: ModelId)->Self{
+		Self::new(other.get())
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
@@ -683,9 +697,9 @@ enum PhysicsModelId{
 	Contact(ContactModelId),
 	Intersect(IntersectModelId),
 }
-impl Into<ModelId> for PhysicsModelId{
-	fn into(self)->ModelId{
-		ModelId::new(match self{
+impl From<PhysicsModelId> for ModelId{
+	fn from(value:PhysicsModelId)->ModelId{
+		ModelId::new(match value{
 			PhysicsModelId::Contact(model_id)=>model_id.get(),
 			PhysicsModelId::Intersect(model_id)=>model_id.get(),
 		})
@@ -693,10 +707,18 @@ impl Into<ModelId> for PhysicsModelId{
 }
 //unique physics meshes indexed by this
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
-struct ConvexMeshId{
-	model_id:PhysicsModelId,
+struct ConvexMeshId<Id>{
+	model_id:Id,
 	submesh_id:PhysicsSubmeshId,
 }
+impl<Id> ConvexMeshId<Id>{
+	fn map<NewId>(self,model_id:NewId)->ConvexMeshId<NewId>{
+		ConvexMeshId{
+			model_id,
+			submesh_id:self.submesh_id,
+		}
+	}
+}
 struct ContactModel{
 	mesh_id:PhysicsMeshId,
 	attr_id:ContactAttributesId,
@@ -710,14 +732,12 @@ struct IntersectModel{
 
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct ContactCollision{
+	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
-	model_id:ContactModelId,
-	submesh_id:PhysicsSubmeshId,
 }
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct IntersectCollision{
-	model_id:IntersectModelId,
-	submesh_id:PhysicsSubmeshId,
+	convex_mesh_id:ConvexMeshId<IntersectModelId>,
 }
 #[derive(Debug,Clone,Eq,Hash,PartialEq)]
 pub enum Collision{
@@ -725,33 +745,39 @@ pub enum Collision{
 	Intersect(IntersectCollision),
 }
 impl Collision{
-	const fn new(convex_mesh_id:ConvexMeshId,face_id:model_physics::MinkowskiFace)->Self{
+	fn new(convex_mesh_id:ConvexMeshId<PhysicsModelId>,face_id:model_physics::MinkowskiFace)->Self{
 		match convex_mesh_id.model_id{
-			PhysicsModelId::Contact(model_id)=>Collision::Contact(ContactCollision{model_id,submesh_id:convex_mesh_id.submesh_id,face_id}),
-			PhysicsModelId::Intersect(model_id)=>Collision::Intersect(IntersectCollision{model_id,submesh_id:convex_mesh_id.submesh_id}),
+			PhysicsModelId::Contact(model_id)=>Collision::Contact(ContactCollision{convex_mesh_id:convex_mesh_id.map(model_id),face_id}),
+			PhysicsModelId::Intersect(model_id)=>Collision::Intersect(IntersectCollision{convex_mesh_id:convex_mesh_id.map(model_id)}),
 		}
 	}
 }
 #[derive(Clone,Debug,Default)]
 struct TouchingState{
-	contacts:HashSet<ContactCollision>,
-	intersects:HashSet<IntersectCollision>,
+	contacts:HashMap<ConvexMeshId<ContactModelId>,model_physics::MinkowskiFace>,
+	intersects:HashSet<ConvexMeshId<IntersectModelId>>,
 }
 impl TouchingState{
 	fn clear(&mut self){
 		self.contacts.clear();
 		self.intersects.clear();
 	}
-	fn insert(&mut self,collision:Collision)->bool{
-		match collision{
-			Collision::Contact(collision)=>self.contacts.insert(collision),
-			Collision::Intersect(collision)=>self.intersects.insert(collision),
-		}
+	fn insert_contact(&mut self,contact:ContactCollision)->Option<model_physics::MinkowskiFace>{
+		self.contacts.insert(contact.convex_mesh_id,contact.face_id)
 	}
-	fn remove(&mut self,collision:&Collision)->bool{
-		match collision{
-			Collision::Contact(collision)=>self.contacts.remove(collision),
-			Collision::Intersect(collision)=>self.intersects.remove(collision),
+	fn insert_intersect(&mut self,intersect:IntersectCollision)->bool{
+		self.intersects.insert(intersect.convex_mesh_id)
+	}
+	fn remove_contact(&mut self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->Option<model_physics::MinkowskiFace>{
+		self.contacts.remove(convex_mesh_id)
+	}
+	fn remove_intersect(&mut self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
+		self.intersects.remove(convex_mesh_id)
+	}
+	fn contains(&self,convex_mesh_id:&ConvexMeshId<PhysicsModelId>)->bool{
+		match convex_mesh_id.model_id{
+			PhysicsModelId::Contact(contact_model_id)=>self.contacts.contains_key(&convex_mesh_id.map(contact_model_id)),
+			PhysicsModelId::Intersect(intersect_model_id)=>self.intersects.contains(&convex_mesh_id.map(intersect_model_id)),
 		}
 	}
 	fn base_acceleration(&self,models:&PhysicsModels,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->Planar64Vec3{
@@ -760,7 +786,7 @@ impl TouchingState{
 			a+=rocket_settings.acceleration(style.get_propulsion_control_dir(camera,input_state.controls));
 		}
 		//add accelerators
-		for contact in &self.contacts{
+		for contact in self.contacts.keys(){
 			if let Some(accelerator)=&models.contact_attr(contact.model_id).general.accelerator{
 				a+=accelerator.acceleration;
 			}
@@ -774,8 +800,8 @@ impl TouchingState{
 		a
 	}
 	fn constrain_velocity(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,velocity:Planar64Vec3)->Planar64Vec3{
-		let contacts:Vec<_>=self.contacts.iter().map(|contact|{
-			let n=contact_normal(models,hitbox_mesh,contact);
+		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
+			let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
 			crate::push_solve::Contact{
 				position:vec3::ZERO,
 				velocity:n,
@@ -785,8 +811,8 @@ impl TouchingState{
 		crate::push_solve::push_solve(&contacts,velocity)
 	}
 	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:Planar64Vec3)->Planar64Vec3{
-		let contacts:Vec<_>=self.contacts.iter().map(|contact|{
-			let n=contact_normal(models,hitbox_mesh,contact);
+		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
+			let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
 			crate::push_solve::Contact{
 				position:vec3::ZERO,
 				velocity:n,
@@ -798,29 +824,29 @@ impl TouchingState{
 	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
-		for contact in &self.contacts{
+		for (convex_mesh_id,face_id) in &self.contacts{
 			//detect face slide off
-			let model_mesh=models.contact_mesh(contact);
+			let model_mesh=models.contact_mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),contact.face_id).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..=collector.time(),*face_id).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
-						Collision::Contact(*contact),
+						Collision::Contact(ContactCollision{face_id:*face_id,convex_mesh_id:*convex_mesh_id}),
 						time
 					),
 				}
 			}));
 		}
-		for intersect in &self.intersects{
+		for convex_mesh_id in &self.intersects{
 			//detect model collision in reverse
-			let model_mesh=models.intersect_mesh(intersect);
+			let model_mesh=models.intersect_mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..=collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
-						Collision::Intersect(*intersect),
+						Collision::Intersect(IntersectCollision{convex_mesh_id:*convex_mesh_id}),
 						time
 					),
 				}
@@ -947,7 +973,7 @@ impl PhysicsState{
 // shared geometry for simulations
 pub struct PhysicsData{
 	//permanent map data
-	bvh:bvh::BvhNode<ConvexMeshId>,
+	bvh:bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	//transient map/environment data (open world loads/unloads parts of this data)
 	models:PhysicsModels,
 	//semi-transient data
@@ -1033,14 +1059,16 @@ impl PhysicsData{
 			let transform=PhysicsMeshTransform::new(model.transform);
 			match attr_id{
 				PhysicsAttributesId::Contact(attr_id)=>{
-					contact_models.insert(ContactModelId::new(model_id as u32),ContactModel{
+					let contact_model_id=ContactModelId::new(model_id as u32);
+					contact_models.insert(contact_model_id,ContactModel{
 						mesh_id,
 						attr_id,
 						transform,
 					});
 				},
 				PhysicsAttributesId::Intersect(attr_id)=>{
-					intersect_models.insert(IntersectModelId::new(model_id as u32),IntersectModel{
+					let intersect_model_id=IntersectModelId::new(model_id as u32);
+					intersect_models.insert(intersect_model_id,IntersectModel{
 						mesh_id,
 						attr_id,
 						transform,
@@ -1054,12 +1082,23 @@ impl PhysicsData{
 				(PhysicsMeshId::new(mesh_id as u32),mesh)
 			).collect();
 		let convex_mesh_aabb_list=
-		//map the two lists into a single type so they can be processed with one closure
-		contact_models.iter().map(|(&model_id,model)|
-			(PhysicsModelId::Contact(model_id),&model.mesh_id,&model.transform)
-		).chain(intersect_models.iter().map(|(&model_id,model)|
-			(PhysicsModelId::Intersect(model_id),&model.mesh_id,&model.transform)
-		))
+		// use the map models iteration order to ensure that the
+		// order that the models are passed into bvh::generate_bvh is consistent
+		map.models.iter().enumerate().filter_map(|(model_id,model)|{
+			match map.attributes.get(model.attributes.get() as usize){
+				None|Some(gameplay_attributes::CollisionAttributes::Decoration)=>None,
+				Some(gameplay_attributes::CollisionAttributes::Contact(_))=>{
+					let model_id=ContactModelId::new(model_id as u32);
+					let model=contact_models.get(&model_id)?;
+					Some((PhysicsModelId::Contact(model_id),&model.mesh_id,&model.transform))
+				},
+				Some(gameplay_attributes::CollisionAttributes::Intersect(_))=>{
+					let model_id=IntersectModelId::new(model_id as u32);
+					let model=intersect_models.get(&model_id)?;
+					Some((PhysicsModelId::Intersect(model_id),&model.mesh_id,&model.transform))
+				},
+			}
+		})
 		.flat_map(|(model_id,mesh_id,transform)|{
 			meshes[mesh_id].submesh_views()
 			.enumerate().map(move|(submesh_id,view)|{
@@ -1150,7 +1189,7 @@ impl<'a> PhysicsContext<'a>{
 		//JUST POLLING!!! NO MUTATION
 		let mut collector=instruction::InstructionCollector::new(time_limit);
 
-		collector.collect(state.next_move_instruction());
+		// collector.collect(state.next_move_instruction());
 
 		//check for collision ends
 		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
@@ -1161,21 +1200,19 @@ impl<'a> PhysicsContext<'a>{
 		//relative to moving platforms
 		//let relative_body=state.body.relative_to(&Body::ZERO);
 		let relative_body=&state.body;
-		data.bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
+		data.bvh.sample_aabb(&aabb,&mut |convex_mesh_id|{
+			if state.touching.contains(convex_mesh_id){
+				return;
+			}
 			//no checks are needed because of the time limits.
-			let model_mesh=data.models.mesh(convex_mesh_id);
+			let model_mesh=data.models.mesh(*convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
-				//temp (?) code to avoid collision loops
-				.and_then(|(face,dt)|{
-					// this must be rounded to avoid the infinite loop when hitting the start zone
-					let time=relative_body.time+dt.into();
-					(state.time<time).then_some((time,face,dt))
-				}).map(|(time,face,dt)|
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..=collector.time())
+				.map(|(face,dt)|
 					TimedInstruction{
-						time,
+						time:relative_body.time+dt.into(),
 						instruction:InternalInstruction::CollisionStart(
-							Collision::new(convex_mesh_id,face),
+							Collision::new(*convex_mesh_id,face),
 							dt
 						)
 					}
@@ -1186,12 +1223,17 @@ impl<'a> PhysicsContext<'a>{
 	}
 
 
-fn contact_normal(models:&PhysicsModels,hitbox_mesh:&HitboxMesh,contact:&ContactCollision)->Planar64Vec3{
-	let model_mesh=models.contact_mesh(contact);
+fn contact_normal(
+	models:&PhysicsModels,
+	hitbox_mesh:&HitboxMesh,
+	convex_mesh_id:&ConvexMeshId<ContactModelId>,
+    face_id:model_physics::MinkowskiFace,
+)->Planar64Vec3{
+	let model_mesh=models.contact_mesh(convex_mesh_id);
 	let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 	// TODO: normalize to i64::MAX>>1
 	// wrap for speed
-	minkowski.face_nd(contact.face_id).0.wrap_1()
+	minkowski.face_nd(face_id).0.wrap_1()
 }
 
 fn recalculate_touching(
@@ -1203,7 +1245,7 @@ fn recalculate_touching(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1212,11 +1254,11 @@ fn recalculate_touching(
 	//collision_end all existing contacts
 	//I would have preferred while let Some(contact)=contacts.pop()
 	//but there is no such method
-	while let Some(&contact)=touching.contacts.iter().next(){
-		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(contact.model_id),contact)
+	while let Some((&convex_mesh_id,_face_id))=touching.contacts.iter().next(){
+		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(convex_mesh_id.model_id),&convex_mesh_id)
 	}
-	while let Some(&intersect)=touching.intersects.iter().next(){
-		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
+	while let Some(&convex_mesh_id)=touching.intersects.iter().next(){
+		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(convex_mesh_id.model_id),&convex_mesh_id,time);
 	}
 	//find all models in the teleport region
 	let mut aabb=aabb::Aabb::default();
@@ -1238,8 +1280,7 @@ fn recalculate_touching(
 				collision_start_intersect(move_state,body,mode_state,touching,mode,run,models,hitbox_mesh,bvh,style,camera,input_state,
 					models.intersect_attr(model_id),
 					IntersectCollision{
-						model_id,
-						submesh_id:convex_mesh_id.submesh_id,
+						convex_mesh_id:convex_mesh_id.map(model_id),
 					},
 					time,
 				),
@@ -1257,7 +1298,7 @@ fn set_position(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1273,8 +1314,8 @@ fn set_position(
 fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
-	touching.contacts.retain(|contact|{
-		let n=contact_normal(models,hitbox_mesh,contact);
+	touching.contacts.retain(|convex_mesh_id,face_id|{
+		let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
 		let r=n.dot(v).is_positive();
 		if r{
 			culled=true;
@@ -1291,8 +1332,8 @@ fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hit
 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;
-	touching.contacts.retain(|contact|{
-		let n=contact_normal(models,hitbox_mesh,contact);
+	touching.contacts.retain(|convex_mesh_id,face_id|{
+		let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
 		let r=n.dot(a).is_positive();
 		if r{
 			culled=true;
@@ -1316,7 +1357,7 @@ fn teleport(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1338,7 +1379,7 @@ fn teleport_to_spawn(
 	mode:&gameplay_modes::Mode,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1427,7 +1468,7 @@ fn run_teleport_behaviour(
 	mode_state:&mut ModeState,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1474,7 +1515,7 @@ fn run_teleport_behaviour(
 	}
 }
 
-fn not_spawn_at(
+fn is_not_spawn_at(
 	mode:Option<&gameplay_modes::Mode>,
 	model_id:ModelId,
 )->bool{
@@ -1495,7 +1536,7 @@ fn collision_start_contact(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1505,12 +1546,12 @@ fn collision_start_contact(
 ){
 	let incident_velocity=body.velocity;
 	//add to touching
-	touching.insert(Collision::Contact(contact));
+	touching.insert_contact(contact);
 	//clip v
 	set_velocity(body,touching,models,hitbox_mesh,incident_velocity);
 	let mut allow_jump=true;
-	let model_id=contact.model_id.into();
-	let mut allow_run_teleport_behaviour=not_spawn_at(mode,model_id);
+	let model_id=contact.convex_mesh_id.model_id.into();
+	let mut allow_run_teleport_behaviour=is_not_spawn_at(mode,model_id);
 	match &attr.contacting.contact_behaviour{
 		Some(gameplay_attributes::ContactingBehaviour::Surf)=>(),
 		Some(gameplay_attributes::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
@@ -1533,7 +1574,7 @@ fn collision_start_contact(
 		},
 		Some(gameplay_attributes::ContactingBehaviour::NoJump)=>allow_jump=false,
 		None=>if let Some(walk_settings)=&style.walk{
-			if walk_settings.is_slope_walkable(contact_normal(models,hitbox_mesh,&contact),vec3::Y){
+			if walk_settings.is_slope_walkable(contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id),vec3::Y){
 				allow_run_teleport_behaviour=true;
 				//ground
 				let (gravity,target_velocity)=ground_things(walk_settings,&contact,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1598,7 +1639,7 @@ fn collision_start_intersect(
 	run:&mut run::Run,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId>,
+	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1607,13 +1648,13 @@ fn collision_start_intersect(
 	time:Time,
 ){
 	//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
-	touching.insert(Collision::Intersect(intersect));
+	touching.insert_intersect(intersect);
 	//insta booster!
 	if let Some(booster)=&attr.general.booster{
 		move_state.cull_velocity(booster.boost(body.velocity),body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
 	if let Some(mode)=mode{
-		let zone=mode.get_zone(intersect.model_id.into());
+		let zone=mode.get_zone(intersect.convex_mesh_id.model_id.into());
 		match zone{
 			Some(gameplay_modes::Zone::Start)=>{
 				println!("@@@@ Starting new run!");
@@ -1630,7 +1671,7 @@ fn collision_start_intersect(
 		}
 	}
 	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);
+	run_teleport_behaviour(intersect.convex_mesh_id.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);
 }
 
 fn collision_end_contact(
@@ -1643,15 +1684,17 @@ fn collision_end_contact(
 	camera:&PhysicsCamera,
 	input_state:&InputState,
 	_attr:&gameplay_attributes::ContactAttributes,
-	contact:ContactCollision,
+	convex_mesh_id:&ConvexMeshId<ContactModelId>,
 ){
-	touching.remove(&Collision::Contact(contact));//remove contact before calling contact_constrain_acceleration
+	touching.remove_contact(convex_mesh_id);//remove contact before calling contact_constrain_acceleration
 	//check ground
 	//TODO do better
 	//this is inner code from move_state.cull_velocity
 	match move_state.get_walk_state(){
 		// did you stop touching the thing you were walking on?
-		Some(walk_state)=>if walk_state.contact==contact{
+		// This does not check the face! Is that a bad thing? It should be
+		// impossible to stop touching a different face than you started touching...
+		Some(walk_state)=>if &walk_state.contact.convex_mesh_id==convex_mesh_id{
 			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 		}else{
 			// stopped touching something else while walking
@@ -1673,13 +1716,13 @@ fn collision_end_intersect(
 	mode:Option<&gameplay_modes::Mode>,
 	run:&mut run::Run,
 	_attr:&gameplay_attributes::IntersectAttributes,
-	intersect:IntersectCollision,
+	convex_mesh_id:&ConvexMeshId<IntersectModelId>,
 	time:Time,
 ){
-	touching.remove(&Collision::Intersect(intersect));
+	touching.remove_intersect(convex_mesh_id);
 	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());
+		let zone=mode.get_zone(convex_mesh_id.model_id.into());
 		match zone{
 			Some(gameplay_modes::Zone::Start)=>{
 				match run.start(time){
@@ -1693,17 +1736,14 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	let (should_advance_body,goober_time)=match ins.instruction{
+	match ins.instruction{
+		// collisions advance the body precisely
 		InternalInstruction::CollisionStart(_,dt)
-		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
-		InternalInstruction::StrafeTick
-		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
-	};
-	if should_advance_body{
-		match goober_time{
-			Some(dt)=>state.body.advance_time_ratio_dt(dt),
-			None=>state.body.advance_time(state.time),
-		}
+		|InternalInstruction::CollisionEnd(_,dt)=>state.body.advance_time_ratio_dt(dt),
+		// this advances imprecisely
+		InternalInstruction::ReachWalkTargetVelocity=>state.body.advance_time(state.time),
+		// strafe tick decides for itself whether to advance the body.
+		InternalInstruction::StrafeTick=>(),
 	}
 		match ins.instruction{
 			InternalInstruction::CollisionStart(collision,_)=>{
@@ -1713,7 +1753,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,&mut state.run,
 						mode,
 						&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
-						data.models.contact_attr(contact.model_id),
+						data.models.contact_attr(contact.convex_mesh_id.model_id),
 						contact,
 						state.time,
 					),
@@ -1721,7 +1761,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,
 						mode,
 						&mut state.run,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
-						data.models.intersect_attr(intersect.model_id),
+						data.models.intersect_attr(intersect.convex_mesh_id.model_id),
 						intersect,
 						state.time,
 					),
@@ -1730,15 +1770,15 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 			InternalInstruction::CollisionEnd(collision,_)=>match collision{
 				Collision::Contact(contact)=>collision_end_contact(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
-					data.models.contact_attr(contact.model_id),
-					contact
+					data.models.contact_attr(contact.convex_mesh_id.model_id),
+					&contact.convex_mesh_id
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
 					&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),
-					intersect,
+					data.models.intersect_attr(intersect.convex_mesh_id.model_id),
+					&intersect.convex_mesh_id,
 					state.time
 				),
 			},
@@ -1750,6 +1790,8 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						let masked_controls=strafe_settings.mask(controls);
 						let control_dir=state.style.get_control_dir(masked_controls);
 						if control_dir!=vec3::ZERO{
+							// manually advance time
+							state.body.advance_time(state.time);
 							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
 							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
@@ -1836,7 +1878,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			if let Some(walk_state)=state.move_state.get_walk_state(){
 				if let Some(jump_settings)=&state.style.jump{
 					let jump_dir=walk_state.jump_direction.direction(&data.models,&data.hitbox_mesh,&walk_state.contact);
-					let booster_option=data.models.contact_attr(walk_state.contact.model_id).general.booster.as_ref();
+					let booster_option=data.models.contact_attr(walk_state.contact.convex_mesh_id.model_id).general.booster.as_ref();
 					let jumped_velocity=jump_settings.jumped_velocity(&state.style,jump_dir,state.body.velocity,booster_option);
 					state.cull_velocity(data,jumped_velocity);
 				}

integration-testing/src/test_scenes.rs

@@ -106,7 +106,9 @@ fn bug_3(){
 		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
 	// touch side of part at 0,0,0
 	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
-	// touch top of part at 5,-5,0
+	// EXPECTED: touch top of part at 5,-5,0
+	// OBSERVED: CollisionEnd part at 0,0,0; clip through part at 5,-5,0
+	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
 	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
 	assert!(phys_iter.next().is_none());
 	let body=physics.body();

lib/fixed_wide/src/fixed.rs

@@ -101,28 +101,6 @@ impl_from!(
 	i8,i16,i32,i64,i128,isize
 );
 
-impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
-where
-		T:Copy,
-		BInt::<N>:From<T>,
-{
-	#[inline]
-	fn eq(&self,&other:&T)->bool{
-		self.bits.eq(&other.into())
-	}
-}
-
-impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
-	where
-		T:Copy,
-		BInt::<N>:From<T>,
-{
-	#[inline]
-	fn partial_cmp(&self,&other:&T)->Option<std::cmp::Ordering>{
-		self.bits.partial_cmp(&other.into())
-	}
-}
-
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;
 	#[inline]
@@ -328,16 +306,6 @@ macro_rules! impl_additive_operator {
 				self.$method(other)
 			}
 		}
-		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
-			where
-				BInt::<N>:From<U>,
-		{
-			type Output = $output;
-			#[inline]
-			fn $method(self, other: U) -> Self::Output {
-				Self::from_bits(self.bits.$method(BInt::<N>::from(other).shl(F as u32)))
-			}
-		}
 	};
 }
 macro_rules! impl_additive_assign_operator {
@@ -348,15 +316,6 @@ macro_rules! impl_additive_assign_operator {
 				self.bits.$method(other.bits);
 			}
 		}
-		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
-		where
-				BInt::<N>:From<U>,
-		{
-			#[inline]
-			fn $method(&mut self, other: U) {
-				self.bits.$method(BInt::<N>::from(other).shl(F as u32));
-			}
-		}
 	};
 }