try code

engine/physics/src/face_crawler.rs

@@ -96,7 +96,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for directed_edge_id in mesh.face_edges(face_id){
+				mesh.for_each_face_edge(face_id,|directed_edge_id|{
 					let edge_n=mesh.directed_edge_n(directed_edge_id);
 					let n=n.cross(edge_n);
 					let &[v0,v1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
@@ -110,7 +110,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
@@ -151,7 +151,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 			},
 			&FEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for directed_edge_id in mesh.vert_edges(vert_id){
+				mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 					//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(trajectory.position-mesh.vert(vert_id)))*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
@@ -162,7 +162,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 		}

engine/physics/src/mesh_query.rs

@@ -26,13 +26,13 @@ pub trait MeshTopology{
 	type Edge:UndirectedEdge<DirectedEdge=Self::DirectedEdge>;
 	type DirectedEdge:DirectedEdge<UndirectedEdge=Self::Edge>;
 	type Vert;
-	fn vert_edges(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::DirectedEdge>;
-	fn vert_faces(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::Face>;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge));
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face));
 	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>;
 	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>;
-	// #[expect(unused)]
-	// fn face_verts(&self,face_id:Self::Face)->impl Iterator<Item=Self::Vert>;
-	fn face_edges(&self,face_id:Self::Face)->impl Iterator<Item=Self::DirectedEdge>;
+	#[expect(unused)]
+	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert));
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge));
 }
 
 // Make face_nd d value relative

engine/physics/src/minimum_difference.rs

@@ -623,7 +623,7 @@ impl<M:MeshQuery<Position=Planar64Vec3>,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){
+		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 			//test if this edge's opposite vertex closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			//select opposite vertex
@@ -636,14 +636,14 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 				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){
+		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 			//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];
@@ -664,7 +664,7 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 					self.best_distance_squared=distance_squared;
 				}
 			}
-		}
+		});
 		best_transition
 	}
 	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>

engine/physics/src/minkowski.rs

@@ -1,10 +1,4 @@
-use core::ops::{Bound,RangeBounds};
-
-use strafesnet_common::integer::{Planar64Vec3,Ratio,Fixed,vec3::Vector3};
-use crate::model::into_giga_time;
-use crate::model::{SubmeshVertId,SubmeshEdgeId,SubmeshDirectedEdgeId,SubmeshFaceId,TransformedMesh,GigaTime};
 use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
-use crate::physics::{Time,Trajectory};
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -13,31 +7,30 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 	}
 }
 
-//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
-//(face,vertex)
-//(edge,edge)
-//(vertex,face)
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
-pub enum MinkowskiVert{
-	VertVert(SubmeshVertId,SubmeshVertId),
+#[derive(Clone,Copy)]
+pub struct MinkowskiVert<M0:MeshTopology,M1:MeshTopology>{
+	vert0:M0::Vert,
+	vert1:M1::Vert,
 }
-// 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)]
+pub enum MinkowskiEdge<M0:MeshTopology,M1:MeshTopology>{
+	VertEdge(M0::Vert,M1::Edge),
+	EdgeVert(M0::Edge,M1::Vert),
 }
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiEdge{
-	VertEdge(SubmeshVertId,SubmeshEdgeId),
-	EdgeVert(SubmeshEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
+#[derive(Clone,Copy)]
+pub enum MinkowskiDirectedEdge<M0:MeshTopology,M1:MeshTopology>{
+	VertEdge(M0::Vert,M1::DirectedEdge),
+	EdgeVert(M0::DirectedEdge,M1::Vert),
 }
-impl UndirectedEdge for MinkowskiEdge{
-	type DirectedEdge=MinkowskiDirectedEdge;
+#[derive(Clone,Copy)]
+pub enum MinkowskiFace<M0:MeshTopology,M1:MeshTopology>{
+	VertFace(M0::Vert,M1::Face),
+	EdgeEdge(M0::Edge,M1::Edge,bool),
+	FaceVert(M0::Face,M1::Vert),
+}
+
+impl<M0:MeshTopology,M1:MeshTopology> UndirectedEdge for MinkowskiEdge<M0,M1>{
+	type DirectedEdge=MinkowskiDirectedEdge<M0,M1>;
 	fn as_directed(self,parity:bool)->Self::DirectedEdge{
 		match self{
 			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
@@ -45,14 +38,8 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiDirectedEdge{
-	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
-	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl DirectedEdge for MinkowskiDirectedEdge{
-	type UndirectedEdge=MinkowskiEdge;
+impl<M0:MeshTopology,M1:MeshTopology> DirectedEdge for MinkowskiDirectedEdge<M0,M1>{
+	type UndirectedEdge=MinkowskiEdge<M0,M1>;
 	fn as_undirected(self)->Self::UndirectedEdge{
 		match self{
 			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
@@ -61,168 +48,39 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 	}
 	fn parity(&self)->bool{
 		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)
-			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
+			MinkowskiDirectedEdge::VertEdge(_,e)=>e.parity(),
+			MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash)]
-pub enum MinkowskiFace{
-	VertFace(SubmeshVertId,SubmeshFaceId),
-	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
-	FaceVert(SubmeshFaceId,SubmeshVertId),
-	//EdgeFace
-	//FaceEdge
-	//FaceFace
-}
-
-#[derive(Debug)]
-pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
-}
-
-// 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{
-			mesh0,
-			mesh1,
-		}
-	}
-	pub fn predict_collision_in(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let start_position=match range.start_bound(){
-			Bound::Included(time)=>trajectory.extrapolated_position(*time),
-			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
-			Bound::Unbounded=>trajectory.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		//continue forwards along the body parabola
-		fev.crawl(self,trajectory,range.start_bound(),range.end_bound()).hit()
-	}
-	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// TODO: handle unbounded collision using infinity fev
-		let start_position=match upper_bound{
-			Bound::Included(time)=>trajectory.extrapolated_position(*time),
-			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
-			Bound::Unbounded=>trajectory.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		// 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 time_reversed_trajectory=-trajectory;
-		//continue backwards along the body parabola
-		fev.crawl(self,&time_reversed_trajectory,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,trajectory:&Trajectory,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=range.start_bound().map(|&t|(t-trajectory.time).to_ratio());
-		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.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){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//f x e points in
-			let n=face_n.cross(edge_n);
-			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-			let d=n.dot(self.vert(v0)+self.vert(v1));
-			//WARNING! d outside of *2
-			//WARNING: truncated precision
-			//wrap for speed
-			for dt in Fixed::<4,128>::zeroes2(((n.dot(trajectory.position))*2-d).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=Bound::Included(dt);
-					best_edge=Some((directed_edge_id,dt));
-					break;
-				}
-			}
-		}
-		best_edge
-	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		crate::minimum_difference::contains_point(self,point)
+pub struct Minkowski<M0,M1>{
+	mesh0:M0,
+	mesh1:M1,
+}
+
+impl<M0,M1> Minkowski<M0,M1>{
+	pub fn sum(mesh0:M0,mesh1:M1)->Self{
+		Self{mesh0,mesh1}
 	}
 }
-impl MeshQuery for MinkowskiMesh<'_>{
-	type Direction=Planar64Vec3;
-	type Position=Planar64Vec3;
-	type Normal=Vector3<Fixed<3,96>>;
-	type Offset=Fixed<4,128>;
-	// TODO: relative d
-	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				let (n,d)=self.mesh1.face_nd(f1);
-				(-n,d-n.dot(self.mesh0.vert(v0)))
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let edge0_n=self.mesh0.edge_n(e0);
-				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				let n=edge0_n.cross(edge1_n);
-				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
-				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				let (n,d)=self.mesh0.face_nd(f0);
-				(n,d-n.dot(self.mesh1.vert(v1)))
-			},
-		}
-	}
-	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				self.mesh0.vert(v0)-self.mesh1.vert(v1)
-			},
-		}
-	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh0.hint_point()-self.mesh1.hint_point()
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
-	}
-	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
-	}
-	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
-}
-impl MeshTopology for MinkowskiMesh<'_>{
-	type Face=MinkowskiFace;
-	type Edge=MinkowskiEdge;
-	type DirectedEdge=MinkowskiDirectedEdge;
-	type Vert=MinkowskiVert;
-	fn vert_edges(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::DirectedEdge>{
+impl<M0:MeshTopology,M1:MeshTopology> MeshTopology for Minkowski<M0,M1>{
+	type Vert=MinkowskiVert<M0,M1>;
+	type Edge=MinkowskiEdge<M0,M1>;
+	type DirectedEdge=MinkowskiDirectedEdge<M0,M1>;
+	type Face=MinkowskiFace<M0,M1>;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,mut f:impl FnMut(Self::DirectedEdge)){
 		match vert_id{
 			MinkowskiVert::VertVert(v0,v1)=>{
 				//detect shared volume when the other mesh is mirrored along a test edge dir
 				let v0f={
 					let mut faces=Vec::new();
-					self.mesh0.vert_faces(v0,|face|faces.push(face));
+					self.mesh0.for_each_vert_face(v0,|face|faces.push(face));
 					faces
 				};
 				let v1f={
 					let mut faces=Vec::new();
-					self.mesh1.vert_faces(v1,|face|faces.push(face));
+					self.mesh1.for_each_vert_face(v1,|face|faces.push(face));
 					faces
 				};
 				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
@@ -230,7 +88,7 @@ impl MeshTopology for MinkowskiMesh<'_>{
 				// scratch vector
 				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
 				face_normals.clone_from(&v0f_n);
-				self.mesh0.vert_edges(v0,|directed_edge_id|{
+				self.mesh0.for_each_vert_edge(v0,|directed_edge_id|{
 					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
@@ -247,7 +105,7 @@ impl MeshTopology for MinkowskiMesh<'_>{
 					}
 				});
 				face_normals.clone_from(&v1f_n);
-				self.mesh1.vert_edges(v1,|directed_edge_id|{
+				self.mesh1.for_each_vert_edge(v1,|directed_edge_id|{
 					let n=self.mesh1.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
 					// drop faces beyond v1f_n
@@ -264,7 +122,7 @@ impl MeshTopology for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn vert_faces(&self,_vert_id:Self::Vert)->impl Iterator<Item=Self::Face>{
+	fn for_each_vert_face(&self,_vert_id:Self::Vert,_f:impl FnMut(Self::Face)){
 		unimplemented!()
 	}
 	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
@@ -273,7 +131,7 @@ impl MeshTopology for MinkowskiMesh<'_>{
 				//faces are listed backwards from the minkowski mesh
 				let v0e={
 					let mut edges=Vec::new();
-					self.mesh0.vert_edges(v0,|edge|edges.push(edge));
+					self.mesh0.for_each_vert_edge(v0,|edge|edges.push(edge));
 					edges
 				};
 				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
@@ -307,7 +165,7 @@ impl MeshTopology for MinkowskiMesh<'_>{
 				//tracking index with an external variable because .enumerate() is not available
 				let v1e={
 					let mut edges=Vec::new();
-					self.mesh1.vert_edges(v1,|edge|edges.push(edge));
+					self.mesh1.for_each_vert_edge(v1,|edge|edges.push(edge));
 					edges
 				};
 				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
@@ -346,13 +204,13 @@ impl MeshTopology for MinkowskiMesh<'_>{
 			),
 		})
 	}
-	// fn face_verts(&self,_face_id:Self::Face)->impl Iterator<Item=Self::Vert>{
-	// 	unimplemented!()
-	// }
-	fn face_edges(&self,face_id:Self::Face)->impl Iterator<Item=Self::DirectedEdge>{
+	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
+		unimplemented!()
+	}
+	fn for_each_face_edge(&self,face_id:Self::Face,mut f:impl FnMut(Self::DirectedEdge)){
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
-				self.mesh1.face_edges(f1,|edge_id1|
+				self.mesh1.for_each_face_edge(f1,|edge_id1|
 					f(MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse()))
 				)
 			},
@@ -367,7 +225,7 @@ impl MeshTopology for MinkowskiMesh<'_>{
 				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1));
 			},
 			MinkowskiFace::FaceVert(f0,v1)=>{
-				self.mesh0.face_edges(f0,|edge_id0|
+				self.mesh0.for_each_face_edge(f0,|edge_id0|
 					f(MinkowskiDirectedEdge::EdgeVert(edge_id0,v1))
 				)
 			},
@@ -375,33 +233,67 @@ impl MeshTopology for MinkowskiMesh<'_>{
 	}
 }
 
-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{
-			let n=normals[i].cross(normals[j]);
-			let mut d_comp=None;
-			for k in 0..len{
-				if k!=i&&k!=j{
-					let d=n.dot(normals[k]).is_negative();
-					if let &Some(comp)=&d_comp{
-						// This is testing if d_comp*d < 0
-						if comp^d{
-							return true;
-						}
-					}else{
-						d_comp=Some(d);
-					}
-				}
-			}
+use strafesnet_common::integer::vec3::Vector3;
+use strafesnet_common::integer::Fixed;
+impl<M0:MeshQuery,M1:MeshQuery> MeshQuery for Minkowski<M0,M1>
+where
+	M0:MeshQuery<
+		Direction=Vector3<Fixed<1,32>>,
+		Position=Vector3<Fixed<1,32>>,
+		Normal=Vector3<Fixed<3,96>>,
+		Offset=Fixed<4,128>,
+	>,
+	M1:MeshQuery<
+		Direction=Vector3<Fixed<1,32>>,
+		Position=Vector3<Fixed<1,32>>,
+		Normal=Vector3<Fixed<3,96>>,
+		Offset=Fixed<4,128>,
+	>,
+{
+	type Direction=M0::Direction;
+	type Position=M0::Position;
+	type Normal=M0::Normal;
+	type Offset=M0::Offset;
+	fn vert(&self,vert_id:MinkowskiVert<M0,M1>)->Planar64Vec3{
+		self.mesh0.vert(vert_id.vert0)-self.mesh1.vert(vert_id.vert1)
+	}
+	fn face_nd(&self,face_id:MinkowskiFace<M0,M1>)->(Self::Normal,Self::Offset){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				let (n,d)=self.mesh1.face_nd(f1);
+				(-n,d-n.dot(self.mesh0.vert(v0)))
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let edge0_n=self.mesh0.edge_n(e0);
+				let edge1_n=self.mesh1.edge_n(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				let n=edge0_n.cross(edge1_n);
+				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
+				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
+				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				let (n,d)=self.mesh0.face_nd(f0);
+				(n,d-n.dot(self.mesh1.vert(v1)))
+			},
 		}
 	}
-	return false;
-}
-
-#[test]
-fn test_is_empty_volume(){
-	use strafesnet_common::integer::vec3;
-	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()]));
+	fn hint_point(&self)->Planar64Vec3{
+		self.mesh0.hint_point()-self.mesh1.hint_point()
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert{
+			vert0:self.mesh0.farthest_vert(dir),
+			vert1:self.mesh1.farthest_vert(-dir),
+		}
+	}
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
 }

engine/physics/src/model.rs

@@ -438,11 +438,11 @@ impl MeshTopology for PhysicsMeshView<'_>{
 	type Edge=SubmeshEdgeId;
 	type DirectedEdge=SubmeshDirectedEdgeId;
 	type Vert=SubmeshVertId;
-	fn vert_edges(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::DirectedEdge>{
-		self.topology.vert_topology[vert_id.get() as usize].edges.iter().copied()
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
+		self.topology.vert_topology[vert_id.get() as usize].edges.iter().copied().for_each(f);
 	}
-	fn vert_faces(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::Face>{
-		self.topology.vert_topology[vert_id.get() as usize].faces.iter().copied()
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
+		self.topology.vert_topology[vert_id.get() as usize].faces.iter().copied().for_each(f);
 	}
 	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].faces)
@@ -450,11 +450,11 @@ impl MeshTopology for PhysicsMeshView<'_>{
 	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].verts)
 	}
-	// fn face_verts(&self,_face_id:Self::Face)->impl Iterator<Item=Self::Vert>{
-	// 	unimplemented!()
-	// }
-	fn face_edges(&self,face_id:Self::Face)->impl Iterator<Item=Self::DirectedEdge>{
-		self.topology.face_topology[face_id.get() as usize].edges.iter().copied()
+	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
+		unimplemented!()
+	}
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
+		self.topology.face_topology[face_id.get() as usize].edges.iter().copied().for_each(f);
 	}
 }
 
@@ -538,12 +538,12 @@ impl MeshTopology for TransformedMesh<'_>{
 	type DirectedEdge=SubmeshDirectedEdgeId;
 	type Vert=SubmeshVertId;
 	#[inline]
-	fn vert_edges(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::DirectedEdge>{
-		self.view.vert_edges(vert_id)
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
+		self.view.for_each_vert_edge(vert_id,f)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::Face>{
-		self.view.vert_faces(vert_id)
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
+		self.view.for_each_vert_face(vert_id,f)
 	}
 	#[inline]
 	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
@@ -553,13 +553,12 @@ impl MeshTopology for TransformedMesh<'_>{
 	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		self.view.edge_verts(edge_id)
 	}
-	// #[inline]
-	// fn face_verts(&self,face_id:Self::Face)->impl Iterator<Item=Self::Vert>{
-	// 	self.view.face_verts(face_id)
-	// }
+	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert)){
+		self.view.for_each_face_vert(face_id,f)
+	}
 	#[inline]
-	fn face_edges(&self,face_id:Self::Face)->impl Iterator<Item=Self::DirectedEdge>{
-		self.view.face_edges(face_id)
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
+		self.view.for_each_face_edge(face_id,f)
 	}
 }
 

engine/physics/src/physics.rs

@@ -868,7 +868,6 @@ pub struct PhysicsState{
 	//gameplay_state
 	mode_state:ModeState,
 	move_state:MoveState,
-	no_clip:bool,
 	//run is non optional: when you spawn in a run is created
 	//the run cannot be finished unless you start it by visiting
 	//a start zone.  If you change mode, a new run is created.
@@ -883,7 +882,6 @@ impl Default for PhysicsState{
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
 			move_state:MoveState::Air,
-			no_clip:false,
 			camera:PhysicsCamera::default(),
 			input_state:InputState::default(),
 			_world:WorldState{},
@@ -1197,11 +1195,6 @@ fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Ti
 	let trajectory=state.body.with_acceleration(state.acceleration(data));
 	//check for collision ends
 	state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&trajectory,state.time);
-
-	if state.no_clip{
-		return collector.take();
-	}
-
 	//check for collision starts
 	let mut aabb=aabb::Aabb::default();
 	trajectory.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1897,7 +1890,6 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 		Instruction::SetControl(SetControlInstruction::SetSprint(s))=>{
 			state.input_state.set_control(Controls::Sprint,s);
-			state.no_clip=s;
 		},
 		Instruction::Mode(ModeInstruction::Reset)=>{
 			//totally reset physics state