compare to infinity fev (notes below)

Looking at the test_collision_parabola_edge_north_from_ne test:
- Inifinity fev seems to return an incorrect value `Face(FaceVert(SubmeshFaceId(1), SubmeshVertId(7)))`, but despite that, the face crawler works.
- the new md algorithm seems to return the correct value `Vert(VertVert(SubmeshVertId(1), SubmeshVertId(6)))`, but the face crawler breaks.

engine/physics/src/minimum_difference.rs

@@ -1,20 +1,23 @@
 use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::integer::{Fixed,Planar64Vec3};
+use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 
-use crate::model::{MeshQuery,MinkowskiMesh,MinkowskiVert};
+use crate::model::{DirectedEdge,FEV,MeshQuery};
+// TODO: remove mesh invert
+use crate::model::{MinkowskiMesh,MinkowskiVert};
 
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
 
-type Simplex<const N:usize>=[MinkowskiVert;N];
-enum Simplex1_3{
-	Simplex1(Simplex<1>),
-	Simplex2(Simplex<2>),
-	Simplex3(Simplex<3>),
+type Simplex<const N:usize,Vert>=[Vert;N];
+#[derive(Clone,Copy)]
+enum Simplex1_3<Vert>{
+	Simplex1(Simplex<1,Vert>),
+	Simplex2(Simplex<2,Vert>),
+	Simplex3(Simplex<3,Vert>),
 }
-impl Simplex1_3{
-	fn push_front(self,v:MinkowskiVert)->Simplex2_4{
+impl<Vert> Simplex1_3<Vert>{
+	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
 		match self{
 			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
 			Simplex1_3::Simplex2([v0,v1])=>Simplex2_4::Simplex3([v,v0,v1]),
@@ -22,10 +25,11 @@ impl Simplex1_3{
 		}
 	}
 }
-enum Simplex2_4{
-	Simplex2(Simplex<2>),
-	Simplex3(Simplex<3>),
-	Simplex4(Simplex<4>),
+#[derive(Clone,Copy)]
+enum Simplex2_4<Vert>{
+	Simplex2(Simplex<2,Vert>),
+	Simplex3(Simplex<3,Vert>),
+	Simplex4(Simplex<4,Vert>),
 }
 
 /*
@@ -41,23 +45,23 @@ local function absDet(r, u, v, w)
 	end
 end
 */
-impl Simplex2_4{
-	fn det_is_zero(&self,mesh:&MinkowskiMesh)->bool{
+impl<Vert> Simplex2_4<Vert>{
+	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
 		match self{
-			&Self::Simplex4([p0,p1,p2,p3])=>{
+			Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				let p2=mesh.vert(p2);
 				let p3=mesh.vert(p3);
 				(p1-p0).cross(p2-p0).dot(p3-p0)==Fixed::ZERO
 			},
-			&Self::Simplex3([p0,p1,p2])=>{
+			Self::Simplex3([p0,p1,p2])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				let p2=mesh.vert(p2);
 				(p1-p0).cross(p2-p0)==vec3::zero()
 			},
-			&Self::Simplex2([p0,p1])=>{
+			Self::Simplex2([p0,p1])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				p1-p0==vec3::zero()
@@ -96,14 +100,14 @@ const fn choose_any_direction()->Planar64Vec3{
 	vec3::X
 }
 
-fn reduce1(
-	[v0]:Simplex<1>,
-	mesh:&MinkowskiMesh,
+fn reduce1<M:MeshQuery>(
+	[v0]:Simplex<1,M::Vert>,
+	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced{
+)->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
-	let p0=-mesh.vert(v0);
+	let p0=mesh.vert(v0);
 
 	// local p = -a
 	let p=-(p0+point);
@@ -125,16 +129,16 @@ fn reduce1(
 }
 
 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2(
-	[v0,v1]:Simplex<2>,
-	mesh:&MinkowskiMesh,
+fn reduce2<M:MeshQuery>(
+	[v0,v1]:Simplex<2,M::Vert>,
+	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced{
+)->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
-	let p0=-mesh.vert(v0);
-	let p1=-mesh.vert(v1);
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
 
 	// local p = -a
 	// local u = b - a
@@ -182,18 +186,18 @@ fn reduce2(
 }
 
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3(
-	[v0,mut v1,v2]:Simplex<3>,
-	mesh:&MinkowskiMesh,
+fn reduce3<M:MeshQuery>(
+	[v0,mut v1,v2]:Simplex<3,M::Vert>,
+	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced{
+)->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	// local c = c1 - c0
-	let p0=-mesh.vert(v0);
-	let p1=-mesh.vert(v1);
-	let p2=-mesh.vert(v2);
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+	let p2=mesh.vert(v2);
 
 	// local p = -a
 	// local u = b - a
@@ -291,20 +295,20 @@ fn reduce3(
 }
 
 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4(
-	[v0,mut v1,mut v2,v3]:Simplex<4>,
-	mesh:&MinkowskiMesh,
+fn reduce4<M:MeshQuery>(
+	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
+	mesh:&M,
 	point:Planar64Vec3,
-)->Reduce{
+)->Reduce<M::Vert>{
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	// local c = c1 - c0
 	// local d = d1 - d0
-	let p0=-mesh.vert(v0);
-	let p1=-mesh.vert(v1);
-	let p2=-mesh.vert(v2);
-	let p3=-mesh.vert(v3);
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+	let p2=mesh.vert(v2);
+	let p3=mesh.vert(v3);
 
 	// local p = -a
 	// local u = b - a
@@ -480,18 +484,18 @@ fn reduce4(
 	})
 }
 
-struct Reduced{
+struct Reduced<Vert>{
 	dir:Planar64Vec3,
-	simplex:Simplex1_3,
+	simplex:Simplex1_3<Vert>,
 }
 
-enum Reduce{
-	Escape(Simplex<4>),
-	Reduced(Reduced),
+enum Reduce<Vert>{
+	Escape(Simplex<4,Vert>),
+	Reduced(Reduced<Vert>),
 }
 
-impl Simplex2_4{
-	fn reduce(self,mesh:&MinkowskiMesh,point:Planar64Vec3)->Reduce{
+impl<Vert> Simplex2_4<Vert>{
+	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
 		match self{
 			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
 			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
@@ -500,57 +504,13 @@ impl Simplex2_4{
 	}
 }
 
-// local function expand(
-// 	queryP, queryQ,
-// 	vertA0, vertA1,
-// 	vertB0, vertB1,
-// 	vertC0, vertC1,
-// 	vertD0, vertD1,
-// 	accuracy
-// )
-fn refine_to_exact(mesh:&MinkowskiMesh,simplex:Simplex<4>)->Simplex2_4{
-	unimplemented!()
-}
-
-/// Intermediate data structure containing a partially complete calculation.
-/// Sometimes you only care about the topology, and not about the
-/// exact point of intersection details.
-pub struct Topology{
-	simplex:Simplex2_4,
-}
-impl Topology{
-	/// Returns None if the point is intersecting the mesh.
-	pub fn closest_point_details(self,mesh:&MinkowskiMesh)->Option<Details>{
-		// NOTE: if hits is true, this if statement necessarily evaluates to true.
-		// i.e. hits implies this statement
-		// if -dist <= exitRadius + radiusP + radiusQ then
-		// 	local posP, posQ = decompose(-point, a0, a1, b0, b1, c0, c1)
-		// 	return hits, -dist - radiusP - radiusQ,
-		// 		posP - radiusP*norm, -norm,
-		// 		posQ + radiusQ*norm, norm
-		// end
-		// return false
-		unimplemented!()
-	}
-}
-pub struct Details{
-	// distance:Planar64,
-	// p_pos:Planar64Vec3,
-	// p_norm:Planar64Vec3,
-	// q_pos:Planar64Vec3,
-	// q_norm:Planar64Vec3,
-}
-
-pub fn contains_point(mesh:&MinkowskiMesh,point:Planar64Vec3)->bool{
+pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 	const ENABLE_FAST_FAIL:bool=true;
-	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
 		// on_exact
-		|last_pos,direction|{
-			// local norm = direction.unit
-			// local dist = a:Dot(norm)
-			// local hits = -dist < radiusP + radiusQ
-			// return hits
-			(last_pos+point).dot(direction).is_positive()
+		|is_intersecting,_simplex|{
+			is_intersecting
 		},
 		// on_escape
 		|_simplex|{
@@ -561,16 +521,248 @@ pub fn contains_point(mesh:&MinkowskiMesh,point:Planar64Vec3)->bool{
 		||false
 	)
 }
-pub fn closest_fev(mesh:&MinkowskiMesh,point:Planar64Vec3)->Topology{
+
+//infinity fev algorithm state transition
+#[derive(Debug)]
+enum Transition<Vert>{
+	Done,//found closest vert, no edges are better
+	Vert(Vert),//transition to vert
+}
+enum EV<M:MeshQuery>{
+	Vert(M::Vert),
+	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+}
+impl<M:MeshQuery> From<EV<M>> for FEV<M>{
+	fn from(value:EV<M>)->Self{
+		match value{
+			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
+			EV::Edge(minkowski_edge)=>FEV::Edge(minkowski_edge),
+		}
+	}
+}
+
+trait Contains{
+	fn contains(&self,point:Planar64Vec3)->bool;
+}
+
+// convenience type to check if a point is within some threshold of a plane.
+struct ThickPlane{
+	point:Planar64Vec3,
+	normal:Vector3<Fixed<2,64>>,
+	epsilon:Fixed<3,96>,
+}
+impl ThickPlane{
+	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+		let p0=mesh.vert(v0);
+		let p1=mesh.vert(v1);
+		let p2=mesh.vert(v2);
+		let point=p0;
+		let normal=(p1-p0).cross(p2-p0);
+		// Allow ~ 2*sqrt(3) units of thickness on the plane
+		// This is to account for the variance of two voxels across the longest diagonal
+		let epsilon=(normal.length()*(Planar64::EPSILON*3)).wrap_3();
+		Self{point,normal,epsilon}
+	}
+}
+impl Contains for ThickPlane{
+	fn contains(&self,point:Planar64Vec3)->bool{
+		(point-self.point).dot(self.normal).abs()<=self.epsilon
+	}
+}
+
+struct ThickLine{
+	point:Planar64Vec3,
+	dir:Planar64Vec3,
+	epsilon:Fixed<4,128>,
+}
+impl ThickLine{
+	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+		let p0=mesh.vert(v0);
+		let p1=mesh.vert(v1);
+		let point=p0;
+		let dir=p1-p0;
+		// Allow ~ 2*sqrt(3) units of thickness on the plane
+		// This is to account for the variance of two voxels across the longest diagonal
+		let epsilon=(dir.length_squared()*(Planar64::EPSILON*3)).widen_4();
+		Self{point,dir,epsilon}
+	}
+}
+impl Contains for ThickLine{
+	fn contains(&self,point:Planar64Vec3)->bool{
+		(point-self.point).cross(self.dir).length_squared()<=self.epsilon
+	}
+}
+
+struct EVFinder<'a,M,C>{
+	mesh:&'a M,
+	constraint:C,
+	best_distance_squared:Fixed<2,64>,
+}
+
+impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
+	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
+		let mut best_transition=Transition::Done;
+		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
+			//test if this edge's opposite vertex closer
+			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
+			//select opposite vertex
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			let test_pos=self.mesh.vert(test_vert_id);
+			let diff=point-test_pos;
+			let distance_squared=diff.dot(diff);
+			// ensure test_vert_id is coplanar to simplex
+			if distance_squared<self.best_distance_squared&&self.constraint.contains(test_pos){
+				best_transition=Transition::Vert(test_vert_id);
+				self.best_distance_squared=distance_squared;
+			}
+		}
+		best_transition
+	}
+	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
+		let mut best_transition=EV::Vert(vert_id);
+		let vert_pos=self.mesh.vert(vert_id);
+		let diff=point-vert_pos;
+		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
+			//test if this edge is closer
+			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			let test_pos=self.mesh.vert(test_vert_id);
+			let edge_n=test_pos-vert_pos;
+			let d=edge_n.dot(diff);
+			//test the edge
+			let edge_nn=edge_n.dot(edge_n);
+			// ensure edge contains closest point and directed_edge_id is coplanar to simplex
+			if !d.is_negative()&&d<=edge_nn&&self.constraint.contains(test_pos){
+				let distance_squared={
+					let c=diff.cross(edge_n);
+					//wrap for speed
+					(c.dot(c)/edge_nn).divide().wrap_2()
+				};
+				if distance_squared<=self.best_distance_squared{
+					best_transition=EV::Edge(directed_edge_id.as_undirected());
+					self.best_distance_squared=distance_squared;
+				}
+			}
+		}
+		best_transition
+	}
+	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
+		loop{
+			match self.next_transition_vert(vert_id,point){
+				Transition::Done=>return self.final_ev(vert_id,point),
+				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
+			}
+		}
+	}
+}
+/// 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 crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
+	// naively start at the closest vertex
+	// the closest vertex is not necessarily the one with the fewest boundary hops
+	// but it doesn't matter, we will get there regardless.
+	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
+		let diff=point-mesh.vert(vert_id);
+		(vert_id,diff.dot(diff))
+	}).min_by_key(|&(_,d)|d).unwrap();
+
+	let constraint=ThickLine::new(mesh,simplex);
+	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
+	//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
+	finder.crawl_boundaries(vert_id,point)
+}
+
+/// 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 crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiVert>,point:Planar64Vec3)->FEV::<MinkowskiMesh<'a>>{
+	// naively start at the closest vertex
+	// the closest vertex is not necessarily the one with the fewest boundary hops
+	// but it doesn't matter, we will get there regardless.
+	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
+		let diff=point-mesh.vert(vert_id);
+		(vert_id,diff.dot(diff))
+	}).min_by_key(|&(_,d)|d).unwrap();
+
+	let constraint=ThickPlane::new(mesh,simplex);
+	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
+	//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
+	match finder.crawl_boundaries(vert_id,point){
+		//if a vert is returned, it is the closest point to the infinity point
+		EV::Vert(vert_id)=>FEV::Vert(vert_id),
+		EV::Edge(edge_id)=>{
+			//cross to face if we are on the wrong side
+			let edge_n=mesh.edge_n(edge_id);
+			// point is multiplied by two because vert_sum sums two vertices.
+			let delta_pos=point*2-{
+				let &[v0,v1]=mesh.edge_verts(edge_id).as_ref();
+				mesh.vert(v0)+mesh.vert(v1)
+			};
+			for (i,&face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
+				//test if this face is closer
+				let (face_n,d)=mesh.face_nd(face_id);
+				//if test point is behind face, the face is invalid
+				// TODO: find out why I thought of this backwards
+				if !(face_n.dot(point)-d).is_positive(){
+					continue;
+				}
+				//edge-face boundary nd, n facing out of the face towards the edge
+				let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
+				let boundary_d=boundary_n.dot(delta_pos);
+				//is test point behind edge, i.e. contained in the face
+				if !boundary_d.is_positive(){
+					//both faces cannot pass this condition, return early if one does.
+					return FEV::Face(face_id);
+				}
+			}
+			FEV::Edge(edge_id)
+		},
+	}
+}
+
+pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
 	const ENABLE_FAST_FAIL:bool=false;
-	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
 		// on_exact
-		|_last_pos,_direction|unimplemented!(),
+		|is_intersecting,simplex|{
+			if is_intersecting{
+				return None;
+			}
+			// Convert simplex to FEV
+			// Vertices must be inverted since the mesh is inverted
+			Some(match simplex{
+				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
+				Simplex1_3::Simplex2([v0,v1])=>{
+					// invert
+					let (v0,v1)=(-v0,-v1);
+					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
+					if !matches!(ev,EV::Edge(_)){
+						println!("I can't believe it's not an edge!");
+					}
+					ev.into()
+				},
+				Simplex1_3::Simplex3([v0,v1,v2])=>{
+					// invert
+					let (v0,v1,v2)=(-v0,-v1,-v2);
+					// Shimmy to the side until you find a face that contains the closest point
+					// it's ALWAYS representable as a face, but this algorithm may
+					// return E or V in edge cases but I don't think that will break the face crawler
+					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
+					if !matches!(fev,FEV::Face(_)){
+						println!("I can't believe it's not a face!");
+					}
+					fev
+				},
+			})
+		},
 		// on_escape
-		|simplex|{
+		|_simplex|{
+			// intersection is guaranteed at this point
 			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
-			let simplex=refine_to_exact(mesh,simplex);
-			Topology{simplex}
+			// let simplex=refine_to_exact(mesh,simplex);
+			None
 		},
 		// fast_fail value is irrelevant and will never be returned!
 		||unreachable!()
@@ -582,25 +774,25 @@ pub fn closest_fev(mesh:&MinkowskiMesh,point:Planar64Vec3)->Topology{
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
-	mesh:&MinkowskiMesh,
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
+	mesh:&M,
 	point:Planar64Vec3,
-	on_exact:impl FnOnce(Planar64Vec3,Planar64Vec3)->T,
-	on_escape:impl FnOnce(Simplex<4>)->T,
+	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
+	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
 	on_fast_fail:impl FnOnce()->T,
 )->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)
 	// local direction, a0, a1, b0, b1, c0, c1, d0, d1
-	let mut initial_axis=-mesh.hint_point()+point;
+	let mut initial_axis=mesh.hint_point()+point;
 	// degenerate case
 	if initial_axis==vec3::zero(){
 		initial_axis=choose_any_direction();
 	}
-	let last_point=mesh.farthest_vert(direction);
+	let last_point=mesh.farthest_vert(-initial_axis);
 	// this represents the 'a' value in the commented code
-	let mut last_pos=-mesh.vert(last_point);
+	let mut last_pos=mesh.vert(last_point);
 	let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);
 
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
@@ -609,8 +801,8 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)
 		// local next_point = new_point_q - new_point_p
-		let next_point=mesh.farthest_vert(-direction);
-		let next_pos=-mesh.vert(next_point);
+		let next_point=mesh.farthest_vert(direction);
+		let next_pos=mesh.vert(next_point);
 
 		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
 		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
@@ -625,7 +817,11 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
 		if !direction.dot(next_pos-last_pos).is_positive()
 		||simplex_big.det_is_zero(mesh){
 			// Found enough information to compute the exact closest point.
-			return on_exact(last_pos,direction);
+			// local norm = direction.unit
+			// local dist = a:Dot(norm)
+			// local hits = -dist < radiusP + radiusQ
+			let is_intersecting=(last_pos+point).dot(direction).is_positive();
+			return on_exact(is_intersecting,simplex_small);
 		}
 
 		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
@@ -646,3 +842,41 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
 		last_pos=next_pos;
 	}
 }
+
+#[cfg(test)]
+mod test{
+	use super::*;
+    use crate::model::{PhysicsMesh,PhysicsMeshView};
+
+    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
+		const ENABLE_FAST_FAIL:bool=true;
+		// TODO: remove mesh negation
+		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
+			// on_exact
+			|is_intersecting,_simplex|{
+				is_intersecting
+			},
+			// on_escape
+			|_simplex|{
+				// intersection is guaranteed at this point
+				true
+			},
+			// fast_fail value
+			||false
+		)
+	}
+
+	#[test]
+	fn test_cube_points(){
+		let mesh=PhysicsMesh::unit_cube();
+		let mesh_view=mesh.complete_mesh_view();
+		for x in -2..=2{
+			for y in -2..=2{
+				for z in -2..=2{
+					let point=vec3::int(x,y,z)>>1;
+					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
+				}
+			}
+		}
+	}
+}

engine/physics/src/minimum_difference_lua.rs

@@ -12,9 +12,9 @@ pub fn contains_point(
 pub fn minimum_difference_details(
 	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->LuaResult<(bool,Details)>{
+)->LuaResult<(bool,Option<Details>)>{
 	let md=minimum_difference(mesh,point,false)?;
-	Ok((md.hits,md.details.unwrap()))
+	Ok((md.hits,md.details))
 }
 fn p64v3(v:Vector)->Result<Planar64Vec3,FixedFromFloatError>{
 	Ok(Planar64Vec3::new([
@@ -65,6 +65,23 @@ impl FromLuaMulti for MinimumDifference{
 					q_norm:p64v3(q_norm).unwrap(),
 				}),
 			}),
+			&mut [
+				mlua::Value::Boolean(hits),
+				mlua::Value::Integer(distance),
+				mlua::Value::Vector(p_pos),
+				mlua::Value::Vector(p_norm),
+				mlua::Value::Vector(q_pos),
+				mlua::Value::Vector(q_norm),
+			]=>Ok(Self{
+				hits,
+				details:Some(Details{
+					distance:distance.into(),
+					p_pos:p64v3(p_pos).unwrap(),
+					p_norm:p64v3(p_norm).unwrap(),
+					q_pos:p64v3(q_pos).unwrap(),
+					q_norm:p64v3(q_norm).unwrap(),
+				}),
+			}),
 			values=>Err(mlua::Error::runtime(format!("Invalid return values: {values:?}"))),
 		}
 	}
@@ -75,7 +92,6 @@ struct Args{
 	radius_p:f64,
 	query_q:Function,
 	radius_q:f64,
-	exit_radius:f64,
 	test_intersection:bool,
 }
 impl Args{
@@ -87,7 +103,6 @@ impl Args{
 	)->LuaResult<Self>{
 		let radius_p=0.0;
 		let radius_q=0.0;
-		let exit_radius=0.0;
 		// Query the farthest point on the mesh in the given direction.
 		let query_p=lua.create_function(move|_,dir:Option<Vector>|{
 			let Some(dir)=dir else{
@@ -113,7 +128,6 @@ impl Args{
 			radius_p,
 			query_q,
 			radius_q,
-			exit_radius,
 			test_intersection,
 		})
 	}
@@ -126,7 +140,7 @@ impl IntoLuaMulti for Args{
 			self.radius_p.into_lua(lua)?,
 			self.query_q.into_lua(lua)?,
 			self.radius_q.into_lua(lua)?,
-			self.exit_radius.into_lua(lua)?,
+			mlua::Value::Nil,
 			self.test_intersection.into_lua(lua)?,
 		]))
 	}

engine/physics/src/model.rs

@@ -92,6 +92,7 @@ pub trait MeshQuery{
 	}
 	/// This must return a point inside the mesh.
 	fn hint_point(&self)->Planar64Vec3;
+	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
 	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
 	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
@@ -434,7 +435,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -453,6 +454,18 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		// invariant: meshes always encompass the origin
 		vec3::zero()
 	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.data.verts[vert_id.get() as usize].0)
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
+	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
@@ -491,7 +504,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -509,18 +522,6 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
-	pub fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
-		//this happens to be well-defined.  there are no virtual virtices
-		SubmeshVertId::new(
-			self.view.topology.verts.iter()
-			.enumerate()
-			.max_by_key(|&(_,&vert_id)|
-				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
-			)
-			//assume there is more than zero vertices.
-			.unwrap().0 as u32
-		)
-	}
 }
 impl MeshQuery for TransformedMesh<'_>{
 	type Face=SubmeshFaceId;
@@ -541,6 +542,18 @@ impl MeshQuery for TransformedMesh<'_>{
 	fn hint_point(&self)->Planar64Vec3{
 		self.transform.vertex.translation
 	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.view.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
+	}
 	#[inline]
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
@@ -571,7 +584,16 @@ impl MeshQuery for TransformedMesh<'_>{
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
-#[derive(Clone,Copy,Debug)]
+// TODO: remove this
+impl core::ops::Neg for MinkowskiVert{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		match self{
+			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -607,7 +629,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Hash)]
 pub enum MinkowskiFace{
 	VertFace(SubmeshVertId,SubmeshFaceId),
 	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
@@ -640,6 +662,14 @@ pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }
 
+// TODO: remove this
+impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
+	type Output=MinkowskiMesh<'a>;
+	fn neg(self)->Self::Output{
+		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
+	}
+}
+
 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
 		MinkowskiMesh{
@@ -647,7 +677,7 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	pub fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
 		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
 	}
 	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
@@ -765,22 +795,23 @@ impl MinkowskiMesh<'_>{
 		})
 	}
 	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,range.start_bound(),range.end_bound()).hit()
-		})
+		let old_fev=self.closest_fev_not_inside(*relative_body,range.start_bound());
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		println!("old_fev={old_fev:?}");
+		println!("fev={fev:?}");
+		//continue forwards along the body parabola
+		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		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,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))
-		})
+		//continue backwards along the body parabola
+		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:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		// TODO: make better
@@ -811,10 +842,7 @@ impl MinkowskiMesh<'_>{
 		best_edge
 	}
 	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		let contains_point_lua=crate::minimum_difference_lua::contains_point(self,point).unwrap();
-		let contains_point=crate::minimum_difference::contains_point(self,point);
-		println!("contains_point={contains_point} contains_point_lua={contains_point_lua}");
-		contains_point
+		crate::minimum_difference::contains_point(self,point)
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -856,6 +884,9 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	fn hint_point(&self)->Planar64Vec3{
 		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
 	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
 	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{

engine/physics/src/physics.rs

@@ -729,7 +729,7 @@ struct IntersectModel{
 	transform:PhysicsMeshTransform,
 }
 
-#[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
+#[derive(Debug,Clone,Copy,Hash)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
@@ -738,7 +738,7 @@ pub struct ContactCollision{
 pub struct IntersectCollision{
 	convex_mesh_id:ConvexMeshId<IntersectModelId>,
 }
-#[derive(Debug,Clone,Eq,Hash,PartialEq)]
+#[derive(Debug,Clone,Hash)]
 pub enum Collision{
 	Contact(ContactCollision),
 	Intersect(IntersectCollision),