debug

Splits the MeshQuery trait into MeshQuery and MeshTopology and cleans up much of the physics traits.  A notable optimization is using a closure for iterating variable length topological lists.  Intermediate allocations are avoided in this way.

Reviewed-on: #33
Co-authored-by: Rhys Lloyd <krakow20@gmail.com>
Co-committed-by: Rhys Lloyd <krakow20@gmail.com>

engine/physics/src/face_crawler.rs

@@ -1,20 +1,21 @@
-use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
-use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
+use crate::model::{into_giga_time,GigaTime};
+use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3,Planar64Vec3};
 use crate::physics::{Time,Trajectory};
+use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
 
 use core::ops::Bound;
 
-enum Transition<M:MeshQuery>{
+enum Transition<M:MeshTopology>{
 	Miss,
 	Next(FEV<M>,GigaTime),
 	Hit(M::Face,GigaTime),
 }
 
-pub enum CrawlResult<M:MeshQuery>{
+pub enum CrawlResult<M:MeshTopology>{
 	Miss(FEV<M>),
 	Hit(M::Face,GigaTime),
 }
-impl<M:MeshQuery> CrawlResult<M>{
+impl<M:MeshTopology> CrawlResult<M>{
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,
@@ -64,11 +65,12 @@ where
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64Vec3,Direction=Planar64Vec3>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
+		M::DirectedEdge:Copy,
 		M::Vert:Copy,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
@@ -94,7 +96,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
+				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();
@@ -108,7 +110,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
@@ -149,7 +151,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&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).as_ref(){
+				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)){
@@ -160,7 +162,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 		}

engine/physics/src/lib.rs

@@ -1,5 +1,6 @@
 mod body;
 mod face_crawler;
+mod mesh_query;
 mod minkowski;
 mod model;
 mod push_solve;

engine/physics/src/mesh_query.rs

@@ -0,0 +1,56 @@
+pub enum FEV<M:MeshTopology>{
+	Vert(M::Vert),
+	Edge(M::Edge),
+	Face(M::Face),
+}
+
+pub trait UndirectedEdge{
+	type DirectedEdge:DirectedEdge<UndirectedEdge=Self>;
+	fn as_directed(self,parity:bool)->Self::DirectedEdge;
+}
+pub trait DirectedEdge{
+	type UndirectedEdge:UndirectedEdge<DirectedEdge=Self>;
+	fn as_undirected(self)->Self::UndirectedEdge;
+	fn parity(&self)->bool;
+	fn reverse(self)->Self
+		where
+			Self:Sized
+	{
+		let parity=!self.parity();
+		self.as_undirected().as_directed(parity)
+	}
+}
+
+pub trait MeshTopology{
+	type Face;
+	type Edge:UndirectedEdge<DirectedEdge=Self::DirectedEdge>;
+	type DirectedEdge:DirectedEdge<UndirectedEdge=Self::Edge>;
+	type Vert;
+	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 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
+// euclidean point?
+// Simplex physics
+// Directed edge necessary?
+// recursive for_each function calls
+// define faces from vertices (Fixed<2> vs Fixed<3>)
+pub trait MeshQuery:MeshTopology{
+	type Position;
+	type Direction;
+	type Normal;
+	type Offset;
+	fn vert(&self,vert_id:Self::Vert)->Self::Position;
+	fn farthest_vert(&self,dir:Self::Direction)->Self::Vert;
+	/// This must return a point inside the mesh.
+	fn hint_point(&self)->Self::Position;
+	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction;
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction;
+}

engine/physics/src/minimum_difference.rs

@@ -2,7 +2,7 @@ use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 
-use crate::model::{DirectedEdge,FEV,MeshQuery};
+use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
 // TODO: remove mesh invert
 use crate::minkowski::{MinkowskiMesh,MinkowskiVert};
 
@@ -46,7 +46,7 @@ local function absDet(r, u, v, w)
 end
 */
 impl<Vert> Simplex2_4<Vert>{
-	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
+	fn det_is_zero<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M)->bool{
 		match self{
 			Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
@@ -131,11 +131,13 @@ fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
 	}.narrow_1().unwrap()
 }
 
-fn reduce1<M:MeshQuery>(
+fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0]:Simplex<1,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced<M::Vert>
+	where M::Vert:Copy,
+{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
 	let p0=mesh.vert(v0);
@@ -160,11 +162,14 @@ fn reduce1<M:MeshQuery>(
 }
 
 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery>(
+fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0,v1]:Simplex<2,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced<M::Vert>
+	where
+		M::Vert:Copy
+{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -217,11 +222,14 @@ fn reduce2<M:MeshQuery>(
 }
 
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery>(
+fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0,mut v1,v2]:Simplex<3,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced<M::Vert>
+	where
+		M::Vert:Copy
+{
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -326,11 +334,14 @@ fn reduce3<M:MeshQuery>(
 }
 
 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<M:MeshQuery>(
+fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduce<M::Vert>{
+)->Reduce<M::Vert>
+	where
+		M::Vert:Copy
+{
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -516,7 +527,10 @@ enum Reduce<Vert>{
 }
 
 impl<Vert> Simplex2_4<Vert>{
-	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
+	fn reduce<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>
+		where
+			M::Vert:Copy
+	{
 		match self{
 			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
 			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
@@ -531,11 +545,11 @@ enum Transition<Vert>{
 	Done,//found closest vert, no edges are better
 	Vert(Vert),//transition to vert
 }
-enum EV<M:MeshQuery>{
+enum EV<M:MeshTopology>{
 	Vert(M::Vert),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+	Edge(M::Edge),
 }
-impl<M:MeshQuery> From<EV<M>> for FEV<M>{
+impl<M:MeshTopology> From<EV<M>> for FEV<M>{
 	fn from(value:EV<M>)->Self{
 		match value{
 			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
@@ -555,7 +569,7 @@ struct ThickPlane{
 	epsilon:Fixed<3,96>,
 }
 impl ThickPlane{
-	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+	fn new<M:MeshQuery<Position=Planar64Vec3>>(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);
@@ -579,7 +593,7 @@ struct ThickLine{
 	epsilon:Fixed<4,128>,
 }
 impl ThickLine{
-	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let point=p0;
@@ -602,10 +616,14 @@ struct EVFinder<'a,M,C>{
 	best_distance_squared:Fixed<2,64>,
 }
 
-impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
+impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
+	where
+		M::Vert:Copy,
+		M::DirectedEdge:Copy,
+{
 	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(){
+		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
@@ -618,14 +636,14 @@ impl<M:MeshQuery,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).as_ref(){
+		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];
@@ -646,10 +664,13 @@ impl<M:MeshQuery,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>{
+	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>
+		where
+			M::Vert:Copy
+	{
 		loop{
 			match self.next_transition_vert(vert_id,point){
 				Transition::Done=>return self.final_ev(vert_id,point),
@@ -659,7 +680,11 @@ impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 	}
 }
 /// This function hops along parallel vertices until it finds the EV which contains the closest point to `point`.
-fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
+fn crawl_to_closest_ev<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>
+	where
+		M::Vert:Copy,
+		M::DirectedEdge:Copy,
+{
 	// 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.
@@ -787,13 +812,16 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar64Vec3,Direction=Planar64Vec3>>(
 	mesh:&M,
 	point:Planar64Vec3,
 	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{
+)->T
+	where
+		M::Vert:Copy
+{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)

engine/physics/src/minkowski.rs

@@ -3,7 +3,7 @@ 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::model::{MeshQuery,DirectedEdge,UndirectedEdge};
+use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
 use crate::physics::{Time,Trajectory};
 
 struct AsRefHelper<T>(T);
@@ -13,7 +13,6 @@ 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)
@@ -134,7 +133,7 @@ impl MinkowskiMesh<'_>{
 		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).as_ref(){
+		self.for_each_face_edge(contact_face_id,|directed_edge_id|{
 			let edge_n=self.directed_edge_n(directed_edge_id);
 			//f x e points in
 			let n=face_n.cross(edge_n);
@@ -150,7 +149,7 @@ impl MinkowskiMesh<'_>{
 					break;
 				}
 			}
-		}
+		});
 		best_edge
 	}
 	pub fn contains_point(&self,point:Planar64Vec3)->bool{
@@ -158,9 +157,8 @@ impl MinkowskiMesh<'_>{
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
-	type Face=MinkowskiFace;
-	type Edge=MinkowskiDirectedEdge;
-	type Vert=MinkowskiVert;
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	// TODO: relative d
@@ -199,21 +197,40 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
 		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
 	}
-	fn vert_edges(&self,vert_id:MinkowskiVert)->impl AsRef<[MinkowskiDirectedEdge]>{
+	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 for_each_vert_edge(&self,vert_id:Self::Vert,mut f:impl FnMut(Self::DirectedEdge)){
 		match vert_id{
 			MinkowskiVert::VertVert(v0,v1)=>{
-				let mut edges=Vec::new();
 				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f_thing=self.mesh0.vert_faces(v0);
-				let v1f_thing=self.mesh1.vert_faces(v1);
-				let v0f=v0f_thing.as_ref();
-				let v1f=v1f_thing.as_ref();
+				let v0f={
+					let mut faces=Vec::new();
+					self.mesh0.for_each_vert_face(v0,|face|faces.push(face));
+					faces
+				};
+				let v1f={
+					let mut faces=Vec::new();
+					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();
 				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
 				// scratch vector
 				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
 				face_normals.clone_from(&v0f_n);
-				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
+				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
@@ -226,11 +243,11 @@ impl MeshQuery for MinkowskiMesh<'_>{
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
 					if is_empty_volume(&face_normals){
-						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
-					}
+						f(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
 					}
+				});
 				face_normals.clone_from(&v1f_n);
-				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
+				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
@@ -241,30 +258,31 @@ impl MeshQuery for MinkowskiMesh<'_>{
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
 					if is_empty_volume(&face_normals){
-						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
+						f(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
 					}
-				}
-				edges
+				});
 			},
 		}
 	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
-		unimplemented!();
-		#[expect(unreachable_code)]
-		Vec::new()
+	fn for_each_vert_face(&self,_vert_id:Self::Vert,_f:impl FnMut(Self::Face)){
+		unimplemented!()
 	}
-	fn edge_faces(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiFace;2]>{
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		match edge_id{
 			MinkowskiEdge::VertEdge(v0,e1)=>{
 				//faces are listed backwards from the minkowski mesh
-				let v0e=self.mesh0.vert_edges(v0);
+				let v0e={
+					let mut edges=Vec::new();
+					self.mesh0.for_each_vert_edge(v0,|edge|edges.push(edge));
+					edges
+				};
 				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
 				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
 					let mut best_edge=None;
 					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
 					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
 					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
-					for &directed_edge_id0 in v0e.as_ref(){
+					for &directed_edge_id0 in &v0e{
 						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
 						//must be behind other face.
 						let d=edge_face1_n.dot(edge0_n);
@@ -287,14 +305,18 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 			MinkowskiEdge::EdgeVert(e0,v1)=>{
 				//tracking index with an external variable because .enumerate() is not available
-				let v1e=self.mesh1.vert_edges(v1);
+				let v1e={
+					let mut edges=Vec::new();
+					self.mesh1.for_each_vert_edge(v1,|edge|edges.push(edge));
+					edges
+				};
 				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
 				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
 					let mut best_edge=None;
 					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
 					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
 					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
-					for &directed_edge_id1 in v1e.as_ref(){
+					for &directed_edge_id1 in &v1e{
 						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
 						let d=edge_face0_n.dot(edge1_n);
 						if d.is_negative(){
@@ -314,7 +336,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		AsRefHelper(match edge_id{
 			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
 				MinkowskiVert::VertVert(v0,vert_id1)
@@ -324,29 +346,30 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			),
 		})
 	}
-	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
+	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).as_ref().iter().map(|&edge_id1|
-					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
-				).collect()
+				self.mesh1.for_each_face_edge(f1,|edge_id1|
+					f(MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse()))
+				)
 			},
 			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
 				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
 				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
 				//could sort this if ordered edges are needed
 				//probably just need to reverse this list according to parity
-				vec![
-					MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0),
-					MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1),
-				]
+				f(MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)));
+				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0));
+				f(MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)));
+				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1));
 			},
 			MinkowskiFace::FaceVert(f0,v1)=>{
-				self.mesh0.face_edges(f0).as_ref().iter().map(|&edge_id0|
-					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
-				).collect()
+				self.mesh0.for_each_face_edge(f0,|edge_id0|
+					f(MinkowskiDirectedEdge::EdgeVert(edge_id0,v1))
+				)
 			},
 		}
 	}

engine/physics/src/model.rs

@@ -3,6 +3,7 @@ use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
+use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -11,20 +12,6 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 	}
 }
 
-pub trait UndirectedEdge{
-	type DirectedEdge:Copy+DirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge;
-}
-pub trait DirectedEdge:Copy{
-	type UndirectedEdge:Copy+std::fmt::Debug+UndirectedEdge;
-	fn as_undirected(self)->Self::UndirectedEdge;
-	fn parity(&self)->bool;
-	//this is stupid but may work fine
-	fn reverse(self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
-		self.as_undirected().as_directed(!self.parity())
-	}
-}
-
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct MeshVertId(u32);
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
@@ -56,14 +43,6 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 	}
 }
 
-//Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug)]
-pub enum FEV<M:MeshQuery>{
-	Face(M::Face),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
-	Vert(M::Vert),
-}
-
 //use Unit32 #[repr(C)] for map files
 #[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 struct Face{
@@ -72,32 +51,6 @@ struct Face{
 }
 #[derive(Debug)]
 struct Vert(Planar64Vec3);
-pub trait MeshQuery{
-	type Face:Copy;
-	type Edge:Copy+DirectedEdge;
-	type Vert:Copy;
-	// Vertex must be Planar64Vec3 because it represents an actual position
-	type Normal;
-	type Offset;
-	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
-		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::Edge)->Planar64Vec3{
-		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)
-	}
-	/// 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]>;
-	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Face;2]>;
-	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Vert;2]>;
-	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
-	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
-}
 #[derive(Debug)]
 struct FaceRefs{
 	// I didn't write it down, but I assume the edges are directed
@@ -442,9 +395,8 @@ pub struct PhysicsMeshView<'a>{
 	topology:&'a PhysicsMeshTopology,
 }
 impl MeshQuery for PhysicsMeshView<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+	type Position=Planar64Vec3;
+	type Direction=Planar64Vec3;
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -472,20 +424,37 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
 		self.data.verts[vert_idx].0
 	}
-	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.topology.vert_topology[vert_id.get() as usize].edges.as_slice()
+	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 vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
-		self.topology.vert_topology[vert_id.get() as usize].faces.as_slice()
+	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)
 	}
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+}
+impl MeshTopology for PhysicsMeshView<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshEdgeId;
+	type DirectedEdge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
+	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 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)
 	}
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+	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_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.topology.face_topology[face_id.get() as usize].edges.as_slice()
+	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);
 	}
 }
 
@@ -525,9 +494,8 @@ impl TransformedMesh<'_>{
 	}
 }
 impl MeshQuery for TransformedMesh<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -555,25 +523,42 @@ impl MeshQuery for TransformedMesh<'_>{
 			.unwrap().0 as u32
 		)
 	}
+	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 TransformedMesh<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshEdgeId;
+	type DirectedEdge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	#[inline]
-	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		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:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
-		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:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		self.view.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		self.view.edge_verts(edge_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:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		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

@@ -1,6 +1,7 @@
 use std::collections::{HashMap,HashSet};
+use crate::mesh_query::MeshQuery;
 use crate::minkowski::{MinkowskiMesh,MinkowskiFace};
-use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
+use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
 use strafesnet_common::run;
@@ -56,6 +57,9 @@ impl InputState{
 	fn replace_mouse(&mut self,mouse:MouseState,next_mouse:MouseState){
 		(self.next_mouse,self.mouse)=(next_mouse,mouse);
 	}
+	fn get_control(&self,control:Controls)->bool{
+		self.controls.contains(control)
+	}
 	fn set_control(&mut self,control:Controls,state:bool){
 		self.controls.set(control,state)
 	}
@@ -921,6 +925,9 @@ impl PhysicsState{
 	pub fn get_finish_time(&self)->Option<run::Time>{
 		self.run.get_finish_time()
 	}
+	fn is_no_clip_enabled(&self)->bool{
+		self.input_state.get_control(Controls::Sprint)
+	}
 	pub fn clear(&mut self){
 		self.touching.clear();
 	}
@@ -1194,6 +1201,11 @@ 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.is_no_clip_enabled(){
+		return collector.take();
+	}
+
 	//check for collision starts
 	let mut aabb=aabb::Aabb::default();
 	trajectory.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1861,7 +1873,8 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			state.input_state.set_next_mouse(m);
 		},
 		Instruction::Mouse(MouseInstruction::ReplaceMouse{m0,m1})=>{
-			state.camera.move_mouse(m0.pos-state.input_state.mouse.pos);
+			state.camera.move_mouse(state.input_state.mouse_delta());
+			state.camera.move_mouse(m0.pos-state.input_state.next_mouse.pos);
 			state.input_state.replace_mouse(m0,m1);
 		},
 		Instruction::Misc(MiscInstruction::SetSensitivity(sensitivity))=>state.camera.sensitivity=sensitivity,

engine/session/src/mouse_interpolator.rs

@@ -138,6 +138,7 @@ impl MouseInterpolator{
 		match buffer_state{
 			BufferState::Unbuffered=>(),
 			BufferState::Initializing(_time,mouse_state)=>{
+				println!("{timeout_time} Time out Initializing");
 				// only a single mouse move was sent in 10ms, this is very much an edge case!
 				self.push_mouse_and_flush_buffer(TimedInstruction{
 					time:mouse_state.time,
@@ -148,6 +149,7 @@ impl MouseInterpolator{
 				});
 			}
 			BufferState::Buffered(_time,mouse_state)=>{
+				println!("{timeout_time} Time out Buffered");
 				// duplicate the currently buffered mouse state but at a later (future, from the physics perspective) time
 				self.push_mouse_and_flush_buffer(TimedInstruction{
 					time:mouse_state.time,
@@ -157,6 +159,7 @@ impl MouseInterpolator{
 		}
 	}
 	fn push_unbuffered_input(&mut self,session_time:SessionTime,physics_time:PhysicsTime,ins:UnbufferedInstruction){
+		println!("helo");
 		// new input
 		// if there is zero instruction buffered, it means the mouse is not moving
 		// case 1: unbuffered
@@ -177,9 +180,11 @@ impl MouseInterpolator{
 					let next_mouse_state=MouseState{pos,time:physics_time};
 					match buffer_state{
 						BufferState::Unbuffered=>{
+							println!("{session_time} Unbuffered -> Initializing");
 							((None,None),BufferState::Initializing(session_time,next_mouse_state))
 						},
 						BufferState::Initializing(_time,mouse_state)=>{
+							println!("{session_time} Initializing -> Buffered");
 							let ins_mouse=TimedInstruction{
 								time:mouse_state.time,
 								instruction:MouseInstruction::ReplaceMouse{
@@ -190,6 +195,7 @@ impl MouseInterpolator{
 							((Some(ins_mouse),None),BufferState::Buffered(session_time,next_mouse_state))
 						},
 						BufferState::Buffered(_time,mouse_state)=>{
+							println!("{session_time} Buffered");
 							let ins_mouse=TimedInstruction{
 								time:mouse_state.time,
 								instruction:MouseInstruction::SetNextMouse(next_mouse_state.clone()),

engine/session/src/session.rs

@@ -221,6 +221,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 			};
 		}
 
+		println!("=== PRE-PROCESS ===");
 		// process any timeouts that occured since the last instruction
 		self.process_exhaustive(ins.time);
 
@@ -422,6 +423,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 			}
 		};
 
+		println!("=== POST-PROCESS ===");
 		// process all emitted output instructions
 		self.process_exhaustive(ins.time);
 	}

lib/fixed_wide/src/fixed.rs

@@ -7,7 +7,7 @@ const BNUM_DIGIT_WIDTH:usize=64;
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
 pub struct Fixed<const N:usize,const F:usize>{
-	pub(crate)bits:BInt<{N}>,
+	bits:BInt<{N}>,
 }
 
 impl<const N:usize,const F:usize> Fixed<N,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{