failed attempt to bypass bug (edge_faces returning two equivalent faces? [FaceVert,EdgeEdge])

engine/physics/src/model.rs

@@ -757,7 +757,7 @@ impl MinkowskiMesh<'_>{
 				.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{start:start_time,end:time_limit}:Range<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		//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={
@@ -787,7 +787,7 @@ impl MinkowskiMesh<'_>{
 				}
 			}
 		}
-		best_edge.map(|e|(e.as_undirected(),best_time))
+		best_edge.map(|e|(e,best_time))
 	}
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);

engine/physics/src/physics.rs

@@ -26,6 +26,8 @@ use strafesnet_common::physics::{Instruction,MouseInstruction,ModeInstruction,Mi
 #[derive(Debug)]
 pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
+	// transfer to a flush minkowski face
+	CollisionTransfer(ContactCollision,model_physics::MinkowskiFace),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
 	ReachWalkTargetVelocity,
@@ -785,19 +787,39 @@ impl TouchingState{
 		crate::push_solve::push_solve(&contacts,acceleration)
 	}
 	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
+		use model_physics::DirectedEdge;
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
 		for contact in &self.contacts{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(contact);
 			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)|{
-				TimedInstruction{
-					time:relative_body.time+time.into(),
-					instruction:InternalInstruction::CollisionEnd(
-						Collision::Contact(*contact),
-						time
-					),
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),contact.face_id).map(|(out_edge,time)|{
+				// TODO: determine if this code should go inside predict_collision_face_out
+				// the face across may be left or right depending on the directed edge parity
+				let &[f0,f1]=minkowski.edge_faces(out_edge.as_undirected()).as_ref();
+				let (f0n,_f0d)=minkowski.face_nd(f0);
+				let (f1n,_f1d)=minkowski.face_nd(f1);
+				// are they exactly flush
+				if f0n.cross(f1n)==vec3::ZERO_6
+				// implicitly don't need to check d values because faces share two vertices
+				// && n0*d1==n1*d0
+				{
+					TimedInstruction{
+						time:relative_body.time+time.into(),
+						instruction:InternalInstruction::CollisionTransfer(
+							*contact,
+							if out_edge.parity(){f1}else{f0},
+						),
+					}
+				}else{
+					TimedInstruction{
+						time:relative_body.time+time.into(),
+						instruction:InternalInstruction::CollisionEnd(
+							Collision::Contact(*contact),
+							time
+						),
+					}
 				}
 			}));
 		}
@@ -1656,6 +1678,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
 		InternalInstruction::StrafeTick
 		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
+		InternalInstruction::CollisionTransfer(..)=>(false,None),
 	};
 	if should_advance_body{
 		match goober_time{
@@ -1700,6 +1723,15 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					state.time
 				),
 			},
+			InternalInstruction::CollisionTransfer(collision,dst_face)=>{
+				// transfer to a flush surface of the same object
+				state.touching.contacts.remove(&collision);
+				state.touching.contacts.insert(ContactCollision{
+					face_id:dst_face,
+					model_id:collision.model_id,
+					submesh_id:collision.submesh_id,
+				});
+			},
 			InternalInstruction::StrafeTick=>{
 				//TODO make this less huge
 				if let Some(strafe_settings)=&state.style.strafe{