From 2a5f610650833001c0c6935fc3d9eb1053adba10 Mon Sep 17 00:00:00 2001
From: Quaternions <krakow20@gmail.com>
Date: Wed, 19 Mar 2025 14:32:40 -0700
Subject: [PATCH 1/4] physics: predict_collision_face_out returns directed edge

---
 engine/physics/src/model.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/engine/physics/src/model.rs b/engine/physics/src/model.rs
index 2c4aece9..a76abce9 100644
--- a/engine/physics/src/model.rs
+++ b/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);
-- 
2.49.1


From b8a0175686f17a7b187a48558ab0a74a12c129ab Mon Sep 17 00:00:00 2001
From: Quaternions <krakow20@gmail.com>
Date: Wed, 19 Mar 2025 14:32:48 -0700
Subject: [PATCH 2/4] physics: flush face transfer

---
 engine/physics/src/physics.rs | 47 +++++++++++++++++++++++++++++------
 1 file changed, 40 insertions(+), 7 deletions(-)

diff --git a/engine/physics/src/physics.rs b/engine/physics/src/physics.rs
index b226795f..6750e23d 100644
--- a/engine/physics/src/physics.rs
+++ b/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,40 @@ 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
+				// check if the face across the out_edge is flush to contact.face_id
+				let (src_face_n,_src_face_d)=minkowski.face_nd(contact.face_id);
+				// the face across may be left or right depending on the directed edge parity
+				let dst_face=minkowski.edge_faces(out_edge.as_undirected()).as_ref()[!out_edge.parity() as usize];
+				let (dst_face_n,_dst_face_d)=minkowski.face_nd(dst_face);
+				// are they exactly flush
+				if src_face_n.cross(dst_face_n)==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,
+							dst_face,
+						),
+					}
+				}else{
+					TimedInstruction{
+						time:relative_body.time+time.into(),
+						instruction:InternalInstruction::CollisionEnd(
+							Collision::Contact(*contact),
+							time
+						),
+					}
 				}
 			}));
 		}
@@ -1656,6 +1679,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 +1724,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{
-- 
2.49.1


From dcdf57b38965024595c5ef83365a6b28b88ad2fd Mon Sep 17 00:00:00 2001
From: Quaternions <krakow20@gmail.com>
Date: Wed, 19 Mar 2025 13:41:07 -0700
Subject: [PATCH 3/4] wrong parity (?)

---
 engine/physics/src/physics.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/engine/physics/src/physics.rs b/engine/physics/src/physics.rs
index 6750e23d..65479c0c 100644
--- a/engine/physics/src/physics.rs
+++ b/engine/physics/src/physics.rs
@@ -799,7 +799,7 @@ impl TouchingState{
 				// check if the face across the out_edge is flush to contact.face_id
 				let (src_face_n,_src_face_d)=minkowski.face_nd(contact.face_id);
 				// the face across may be left or right depending on the directed edge parity
-				let dst_face=minkowski.edge_faces(out_edge.as_undirected()).as_ref()[!out_edge.parity() as usize];
+				let dst_face=minkowski.edge_faces(out_edge.as_undirected()).as_ref()[out_edge.parity() as usize];
 				let (dst_face_n,_dst_face_d)=minkowski.face_nd(dst_face);
 				// are they exactly flush
 				if src_face_n.cross(dst_face_n)==vec3::ZERO_6
-- 
2.49.1


From 05999f73f423e8c8506338dbe1b31fd45ef9ca0f Mon Sep 17 00:00:00 2001
From: Quaternions <krakow20@gmail.com>
Date: Wed, 19 Mar 2025 14:55:04 -0700
Subject: [PATCH 4/4] failed attempt to bypass bug (edge_faces returning two
 equivalent faces? [FaceVert,EdgeEdge])

---
 engine/physics/src/physics.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/engine/physics/src/physics.rs b/engine/physics/src/physics.rs
index 65479c0c..22f7a26f 100644
--- a/engine/physics/src/physics.rs
+++ b/engine/physics/src/physics.rs
@@ -796,13 +796,12 @@ impl TouchingState{
 			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(|(out_edge,time)|{
 				// TODO: determine if this code should go inside predict_collision_face_out
-				// check if the face across the out_edge is flush to contact.face_id
-				let (src_face_n,_src_face_d)=minkowski.face_nd(contact.face_id);
 				// the face across may be left or right depending on the directed edge parity
-				let dst_face=minkowski.edge_faces(out_edge.as_undirected()).as_ref()[out_edge.parity() as usize];
-				let (dst_face_n,_dst_face_d)=minkowski.face_nd(dst_face);
+				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 src_face_n.cross(dst_face_n)==vec3::ZERO_6
+				if f0n.cross(f1n)==vec3::ZERO_6
 				// implicitly don't need to check d values because faces share two vertices
 				// && n0*d1==n1*d0
 				{
@@ -810,7 +809,7 @@ impl TouchingState{
 						time:relative_body.time+time.into(),
 						instruction:InternalInstruction::CollisionTransfer(
 							*contact,
-							dst_face,
+							if out_edge.parity(){f1}else{f0},
 						),
 					}
 				}else{
-- 
2.49.1