debug

Cargo.lock

@@ -3904,6 +3904,7 @@ dependencies = [
  "arrayvec",
  "glam",
  "id",
+ "mlua",
  "strafesnet_common",
 ]
 

engine/graphics/src/graphics.rs

@@ -909,7 +909,7 @@ impl GraphicsState{
 
 		// update rotation
 		let camera_uniforms=self.camera.to_uniform_data(
-			frame_state.trajectory.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
+			frame_state.body.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
 			frame_state.camera.simulate_move_angles(glam::IVec2::ZERO)
 		);
 		self.staging_belt

engine/physics/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 arrayvec = "0.7.6"
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
+mlua = { version = "0.11.5", features = ["luau"] }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 
 [lints]

engine/physics/src/body.rs

@@ -2,18 +2,12 @@ use strafesnet_common::aabb;
 use strafesnet_common::integer::{self,vec3,Time,Planar64,Planar64Vec3};
 #[derive(Clone,Copy,Debug,Hash)]
 pub struct Body<T>{
-	pub position:Planar64Vec3,
-	pub velocity:Planar64Vec3,
-	pub time:Time<T>,
+	pub position:Planar64Vec3,//I64 where 2^32 = 1 u
+	pub velocity:Planar64Vec3,//I64 where 2^32 = 1 u/s
+	pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
+	pub time:Time<T>,//nanoseconds x xxxxD!
 }
-#[derive(Clone,Copy,Debug,Hash)]
-pub struct Trajectory<T>{
-	pub position:Planar64Vec3,
-	pub velocity:Planar64Vec3,
-	pub acceleration:Planar64Vec3,
-	pub time:Time<T>,
-}
-impl<T> std::ops::Neg for Trajectory<T>{
+impl<T> std::ops::Neg for Body<T>{
 	type Output=Self;
 	fn neg(self)->Self::Output{
 		Self{
@@ -24,10 +18,10 @@ impl<T> std::ops::Neg for Trajectory<T>{
 		}
 	}
 }
-impl<T:Copy> std::ops::Neg for &Trajectory<T>{
-	type Output=Trajectory<T>;
+impl<T:Copy> std::ops::Neg for &Body<T>{
+	type Output=Body<T>;
 	fn neg(self)->Self::Output{
-		Trajectory{
+		Body{
 			position:self.position,
 			velocity:-self.velocity,
 			acceleration:self.acceleration,
@@ -38,32 +32,6 @@ impl<T:Copy> std::ops::Neg for &Trajectory<T>{
 
 impl<T> Body<T>
 	where Time<T>:Copy,
-{
-	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),Time::ZERO);
-	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,time:Time<T>)->Self{
-		Self{
-			position,
-			velocity,
-			time,
-		}
-	}
-	pub const fn with_acceleration(self,acceleration:Planar64Vec3)->Trajectory<T>{
-		let Body{
-			position,
-			velocity,
-			time,
-		}=self;
-		Trajectory{
-			position,
-			velocity,
-			acceleration,
-			time,
-		}
-	}
-}
-
-impl<T> Trajectory<T>
-	where Time<T>:Copy,
 {
 	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),vec3::zero(),Time::ZERO);
 	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3,time:Time<T>)->Self{
@@ -74,14 +42,13 @@ impl<T> Trajectory<T>
 			time,
 		}
 	}
-	pub fn relative_to(&self,trj0:&Self,time:Time<T>)->Self{
+	pub const fn relative_to<'a>(&'a self,body0:&'a Body<T>)->VirtualBody<'a,T>{
 		//(p0,v0,a0,t0)
 		//(p1,v1,a1,t1)
-		Trajectory::new(
-			self.extrapolated_position(time)-trj0.extrapolated_position(time),
-			self.extrapolated_velocity(time)-trj0.extrapolated_velocity(time),
-			self.acceleration-trj0.acceleration,
-			time)
+		VirtualBody{
+			body0,
+			body1:self,
+		}
 	}
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
@@ -93,12 +60,10 @@ impl<T> Trajectory<T>
 		let dt=time-self.time;
 		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().clamp_1())
 	}
-	pub fn extrapolated_body(&self,time:Time<T>)->Body<T>{
-		Body::new(
-			self.extrapolated_position(time),
-			self.extrapolated_velocity(time),
-			time,
-		)
+	pub fn advance_time(&mut self,time:Time<T>){
+		self.position=self.extrapolated_position(time);
+		self.velocity=self.extrapolated_velocity(time);
+		self.time=time;
 	}
 	pub fn extrapolated_position_ratio_dt<Num,Den,N1,D1,N2,N3,D2,N4,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
 		where
@@ -136,12 +101,10 @@ impl<T> Trajectory<T>
 		// a*dt + v
 		self.acceleration.map(|elem|(dt*elem).divide().clamp())+self.velocity
 	}
-	pub fn extrapolated_body_ratio_dt(&self,dt:crate::model::GigaTime)->Body<T>{
-		Body::new(
-			self.extrapolated_position_ratio_dt(dt),
-			self.extrapolated_velocity_ratio_dt(dt),
-			self.time+dt.into(),
-		)
+	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
+		self.position=self.extrapolated_position_ratio_dt(dt);
+		self.velocity=self.extrapolated_velocity_ratio_dt(dt);
+		self.time+=dt.into();
 	}
 	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
 		if self.velocity==vec3::zero(){
@@ -181,12 +144,28 @@ impl<T> Trajectory<T>
 
 }
 impl<T> std::fmt::Display for Body<T>{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"p({}) v({}) t({})",self.position,self.velocity,self.time)
-	}
-}
-impl<T> std::fmt::Display for Trajectory<T>{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"p({}) v({}) a({}) t({})",self.position,self.velocity,self.acceleration,self.time)
 	}
 }
+
+pub struct VirtualBody<'a,T>{
+	body0:&'a Body<T>,
+	body1:&'a Body<T>,
+}
+impl<T> VirtualBody<'_,T>
+	where Time<T>:Copy,
+{
+	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
+		self.body1.extrapolated_position(time)-self.body0.extrapolated_position(time)
+	}
+	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
+		self.body1.extrapolated_velocity(time)-self.body0.extrapolated_velocity(time)
+	}
+	pub fn acceleration(&self)->Planar64Vec3{
+		self.body1.acceleration-self.body0.acceleration
+	}
+	pub fn body(&self,time:Time<T>)->Body<T>{
+		Body::new(self.extrapolated_position(time),self.extrapolated_velocity(time),self.acceleration(),time)
+	}
+}

engine/physics/src/face_crawler.rs

@@ -1,21 +1,20 @@
-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 crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
+use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
+use crate::physics::{Time,Body};
 
 use core::ops::Bound;
 
-enum Transition<M:MeshTopology>{
+enum Transition<M:MeshQuery>{
 	Miss,
 	Next(FEV<M>,GigaTime),
 	Hit(M::Face,GigaTime),
 }
 
-pub enum CrawlResult<M:MeshTopology>{
+pub enum CrawlResult<M:MeshQuery>{
 	Miss(FEV<M>),
 	Hit(M::Face,GigaTime),
 }
-impl<M:MeshTopology> CrawlResult<M>{
+impl<M:MeshQuery> CrawlResult<M>{
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,
@@ -65,18 +64,17 @@ where
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64Vec3,Direction=Planar64Vec3>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> 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,
 		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition(&self,mesh:&M,trajectory:&Trajectory,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
+	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -88,23 +86,23 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 				let (n,d)=mesh.face_nd(face_id);
 				//TODO: use higher precision d value?
 				//use the mesh transform translation instead of baking it into the d value.
-				for dt in Fixed::<4,128>::zeroes2((n.dot(trajectory.position)-d)*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
-					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 						upper_bound=Bound::Included(dt);
 						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for directed_edge_id in mesh.face_edges(face_id){
+				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
 					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();
 					//WARNING: d is moved out of the *2 block because of adding two vertices!
 					//WARNING: precision is swept under the rug!
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(trajectory.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
@@ -119,15 +117,15 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 				let &[ev0,ev1]=edge_verts.as_ref();
 				let (v0,v1)=(mesh.vert(ev0),mesh.vert(ev1));
 				let edge_n=v1-v0;
-				let delta_pos=trajectory.position*2-(v0+v1);
+				let delta_pos=body.position*2-(v0+v1);
 				for (i,&edge_face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=mesh.face_nd(edge_face_id).0;
 					//edge_n gets parity from the order of edge_faces
 					let n=face_n.cross(edge_n)*((i as i64)*2-1);
 					//WARNING yada yada d *2
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
@@ -138,8 +136,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 				for (i,&vert_id) in edge_verts.as_ref().iter().enumerate(){
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
-					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)){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
@@ -151,11 +149,11 @@ 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){
+				for &directed_edge_id in mesh.vert_edges(vert_id).as_ref(){
 					//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)){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
@@ -168,11 +166,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 		}
 		best_transition
 	}
-	pub fn crawl(mut self,mesh:&M,trajectory:&Trajectory,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
-		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,trajectory.time));
-		let upper_bound=upper_bound.map(|&t|into_giga_time(t,trajectory.time));
+	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
+		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
 		for _ in 0..20{
-			match self.next_transition(mesh,trajectory,lower_bound,upper_bound){
+			match self.next_transition(mesh,relative_body,lower_bound,upper_bound){
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/lib.rs

@@ -1,10 +1,9 @@
 mod body;
 mod face_crawler;
-mod mesh_query;
-mod minkowski;
 mod model;
 mod push_solve;
 mod minimum_difference;
+mod minimum_difference_lua;
 
 pub mod physics;
 

engine/physics/src/mesh_query.rs

@@ -1,56 +0,0 @@
-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 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 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>;
-}
-
-// 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,15 +2,15 @@ use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 
-use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
+use crate::model::{DirectedEdge,FEV,MeshQuery};
 // TODO: remove mesh invert
-use crate::minkowski::{MinkowskiMesh,MinkowskiVert};
+use crate::model::{MinkowskiMesh,MinkowskiVert};
 
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
 
 type Simplex<const N:usize,Vert>=[Vert;N];
-#[derive(Clone,Copy)]
+#[derive(Clone,Copy,Debug)]
 enum Simplex1_3<Vert>{
 	Simplex1(Simplex<1,Vert>),
 	Simplex2(Simplex<2,Vert>),
@@ -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,Position=Planar64Vec3>>(self,mesh:&M)->bool{
+	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
 		match self{
 			Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
@@ -131,19 +131,20 @@ fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
 	}.narrow_1().unwrap()
 }
 
-fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce1<M:MeshQuery>(
 	[v0]:Simplex<1,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>
-	where M::Vert:Copy,
-{
+)->Reduced<M::Vert>{
+	println!("reduce1");
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
 	let p0=mesh.vert(v0);
 
+	println!("p0={p0}");
 	// local p = -a
 	let p=-(p0+point);
+	println!("p={p}");
 
 	// local direction = p
 	let mut dir=p;
@@ -162,14 +163,12 @@ fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
 }
 
 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce2<M:MeshQuery>(
 	[v0,v1]:Simplex<2,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>
-	where
-		M::Vert:Copy
-{
+)->Reduced<M::Vert>{
+	println!("reduce2");
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -222,14 +221,12 @@ fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
 }
 
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce3<M:MeshQuery>(
 	[v0,mut v1,v2]:Simplex<3,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>
-	where
-		M::Vert:Copy
-{
+)->Reduced<M::Vert>{
+	println!("reduce3");
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -334,14 +331,12 @@ fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 }
 
 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce4<M:MeshQuery>(
 	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduce<M::Vert>
-	where
-		M::Vert:Copy
-{
+)->Reduce<M::Vert>{
+	println!("reduce4");
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -527,10 +522,7 @@ enum Reduce<Vert>{
 }
 
 impl<Vert> Simplex2_4<Vert>{
-	fn reduce<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>
-		where
-			M::Vert:Copy
-	{
+	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)),
@@ -545,11 +537,11 @@ enum Transition<Vert>{
 	Done,//found closest vert, no edges are better
 	Vert(Vert),//transition to vert
 }
-enum EV<M:MeshTopology>{
+enum EV<M:MeshQuery>{
 	Vert(M::Vert),
-	Edge(M::Edge),
+	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
 }
-impl<M:MeshTopology> From<EV<M>> for FEV<M>{
+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),
@@ -569,7 +561,7 @@ struct ThickPlane{
 	epsilon:Fixed<3,96>,
 }
 impl ThickPlane{
-	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+	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);
@@ -593,7 +585,7 @@ struct ThickLine{
 	epsilon:Fixed<4,128>,
 }
 impl ThickLine{
-	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+	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;
@@ -616,14 +608,10 @@ struct EVFinder<'a,M,C>{
 	best_distance_squared:Fixed<2,64>,
 }
 
-impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
-	where
-		M::Vert:Copy,
-		M::DirectedEdge:Copy,
-{
+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){
+		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
@@ -643,7 +631,7 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 		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){
+		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];
@@ -667,10 +655,7 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 		}
 		best_transition
 	}
-	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>
-		where
-			M::Vert:Copy
-	{
+	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),
@@ -679,12 +664,8 @@ impl<M:MeshQuery<Position=Planar64Vec3>,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<Position=Planar64Vec3>>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>
-	where
-		M::Vert:Copy,
-		M::DirectedEdge:Copy,
-{
+/// 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.
@@ -701,7 +682,7 @@ fn crawl_to_closest_ev<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,simplex:Simpl
 	finder.crawl_boundaries(vert_id,point)
 }
 
-/// This function hops along connected vertices until it finds the FEV which contains the closest point to `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
@@ -750,11 +731,21 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 }
 
 pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+	println!("=== LUA ===");
+	let (hits,_details)=crate::minimum_difference_lua::minimum_difference_details(mesh,point).unwrap();
+	println!("=== RUST ===");
+	let closest_fev_not_inside=closest_fev_not_inside_inner(mesh,point);
+	assert_eq!(hits,closest_fev_not_inside.is_none(),"algorithms disagree");
+	closest_fev_not_inside
+}
+
+fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
 	const ENABLE_FAST_FAIL:bool=false;
 	// TODO: remove mesh negation
 	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
 		// on_exact
 		|is_intersecting,simplex|{
+			println!("on_exact is_intersecting={is_intersecting} simplex={simplex:?}");
 			if is_intersecting{
 				return None;
 			}
@@ -812,16 +803,13 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar64Vec3,Direction=Planar64Vec3>>(
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	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
-	where
-		M::Vert:Copy
-{
+)->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)
@@ -831,6 +819,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar6
 	if initial_axis==vec3::zero(){
 		initial_axis=choose_any_direction();
 	}
+	println!("initial_axis={initial_axis}");
 	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);
@@ -839,6 +828,8 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar6
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
 	// for _ = 1, 100 do
 	loop{
+		println!("direction={direction}");
+
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)
 		// local next_point = new_point_q - new_point_p
@@ -846,7 +837,11 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar6
 		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(){
+		let d=direction.dot(next_pos+point);
+		let fast_fail=d.is_negative();
+		println!("ENABLE_FAST_FAIL={ENABLE_FAST_FAIL} fast_fail={fast_fail} next_point={} dot={d}",next_pos+point);
+		if ENABLE_FAST_FAIL&&fast_fail{
+			println!("on_fast_fail");
 			return on_fast_fail();
 		}
 
@@ -855,8 +850,11 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar6
 		// if
 		// 	direction:Dot(next_point - a) <= 0 or
 		// 	absDet(next_point, a, b, c) < 1e-6
-		if !direction.dot(next_pos-last_pos).is_positive()
-		||simplex_big.det_is_zero(mesh){
+		let cond1=!direction.dot(next_pos-last_pos).is_positive();
+		let cond2=simplex_big.det_is_zero(mesh);
+		println!("cond1={cond1} cond2={cond2}");
+		if cond1||cond2{
+			println!("on_exact");
 			// Found enough information to compute the exact closest point.
 			// local norm = direction.unit
 			// local dist = a:Dot(norm)
@@ -869,6 +867,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar6
 		match simplex_big.reduce(mesh,point){
 			// if a and b and c and d then
 			Reduce::Escape(simplex)=>{
+				println!("on_escape");
 				// Enough information to conclude that the meshes are intersecting.
 				// Topology information is computed if needed.
 				return on_escape(simplex);

engine/physics/src/minimum_difference_lua.rs

@@ -0,0 +1,173 @@
+use mlua::{Lua,FromLuaMulti,IntoLuaMulti,Function,Result as LuaResult,Vector};
+use strafesnet_common::integer::{Planar64,Planar64Vec3,FixedFromFloatError};
+
+use crate::model::{MeshQuery,MinkowskiMesh};
+
+pub fn contains_point(
+	mesh:&MinkowskiMesh,
+	point:Planar64Vec3,
+)->LuaResult<bool>{
+	Ok(minimum_difference(mesh,point,true)?.hits)
+}
+pub fn minimum_difference_details(
+	mesh:&MinkowskiMesh,
+	point:Planar64Vec3,
+)->LuaResult<(bool,Option<Details>)>{
+	let md=minimum_difference(mesh,point,false)?;
+	Ok((md.hits,md.details))
+}
+fn p64v3(v:Vector)->Result<Planar64Vec3,FixedFromFloatError>{
+	Ok(Planar64Vec3::new([
+		v.x().try_into()?,
+		v.y().try_into()?,
+		v.z().try_into()?,
+	]))
+}
+fn vec(v:Planar64Vec3)->Vector{
+	Vector::new(v.x.into(),v.y.into(),v.z.into())
+}
+struct MinimumDifference{
+	hits:bool,
+	details:Option<Details>
+}
+pub struct Details{
+	pub distance:Planar64,
+	pub p_pos:Planar64Vec3,
+	pub p_norm:Planar64Vec3,
+	pub q_pos:Planar64Vec3,
+	pub q_norm:Planar64Vec3,
+}
+impl FromLuaMulti for MinimumDifference{
+	fn from_lua_multi(mut values:mlua::MultiValue,_lua:&Lua)->LuaResult<Self>{
+		match values.make_contiguous(){
+			&mut [
+				mlua::Value::Boolean(hits),
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+			]=>Ok(Self{hits,details:None}),
+			&mut [
+				mlua::Value::Boolean(hits),
+				mlua::Value::Number(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.try_into().unwrap(),
+					p_pos:p64v3(p_pos).unwrap(),
+					p_norm:p64v3(p_norm).unwrap(),
+					q_pos:p64v3(q_pos).unwrap(),
+					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:?}"))),
+		}
+	}
+}
+
+struct Args{
+	query_p:Function,
+	radius_p:f64,
+	query_q:Function,
+	radius_q:f64,
+	test_intersection:bool,
+}
+impl Args{
+	fn new(
+		lua:&Lua,
+		mesh:&'static MinkowskiMesh<'static>,
+		point:Planar64Vec3,
+		test_intersection:bool,
+	)->LuaResult<Self>{
+		let radius_p=0.0;
+		let radius_q=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{
+				return Ok(vec(mesh.mesh0.hint_point()));
+			};
+			let dir=p64v3(dir).unwrap();
+			let vert_id=mesh.mesh0.farthest_vert(dir);
+			let dir=mesh.mesh0.vert(vert_id);
+			Ok(vec(dir))
+		})?;
+		// query_q is different since it includes the test point offset.
+		let query_q=lua.create_function(move|_,dir:Option<Vector>|{
+			let Some(dir)=dir else{
+				return Ok(vec(mesh.mesh1.hint_point()+point));
+			};
+			let dir=p64v3(dir).unwrap();
+			let vert_id=mesh.mesh1.farthest_vert(dir);
+			let dir=mesh.mesh1.vert(vert_id)+point;
+			Ok(vec(dir))
+		})?;
+		Ok(Args{
+			query_p,
+			radius_p,
+			query_q,
+			radius_q,
+			test_intersection,
+		})
+	}
+}
+impl IntoLuaMulti for Args{
+	fn into_lua_multi(self,lua:&Lua)->LuaResult<mlua::MultiValue>{
+		use mlua::IntoLua;
+		Ok(mlua::MultiValue::from_vec(vec![
+			self.query_p.into_lua(lua)?,
+			self.radius_p.into_lua(lua)?,
+			self.query_q.into_lua(lua)?,
+			self.radius_q.into_lua(lua)?,
+			mlua::Value::Nil,
+			self.test_intersection.into_lua(lua)?,
+		]))
+	}
+}
+
+fn minimum_difference(
+	mesh:&MinkowskiMesh,
+	point:Planar64Vec3,
+	test_intersection:bool,
+)->LuaResult<MinimumDifference>{
+	let ctx=init_lua()?;
+	// SAFETY: mesh lifetime must outlive args usages
+	let mesh=unsafe{core::mem::transmute(mesh)};
+	let args=Args::new(&ctx.lua,mesh,point,test_intersection)?;
+	ctx.f.call(args)
+}
+
+struct Ctx{
+	lua:Lua,
+	f:Function,
+}
+fn init_lua()->LuaResult<Ctx>{
+	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("/home/quat/strafesnet/strafe-project/Trey-MinimumDifference.lua").unwrap());
+	let lua=Lua::new();
+	lua.sandbox(true)?;
+	let lib_f=lua.load(SOURCE.as_str()).set_name("Trey-MinimumDifference").into_function()?;
+	let lib:mlua::Table=lib_f.call(())?;
+	let f=lib.raw_get("difference")?;
+	Ok(Ctx{lua,f})
+}

engine/physics/src/minkowski.rs

@@ -1,407 +0,0 @@
-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>{
-	fn as_ref(&self)->&T{
-		&self.0
-	}
-}
-
-//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),
-}
-// 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)]
-pub enum MinkowskiEdge{
-	VertEdge(SubmeshVertId,SubmeshEdgeId),
-	EdgeVert(SubmeshEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl UndirectedEdge for MinkowskiEdge{
-	type DirectedEdge=MinkowskiDirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge{
-		match self{
-			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
-			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),v1),
-		}
-	}
-}
-#[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;
-	fn as_undirected(self)->Self::UndirectedEdge{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
-			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),v1),
-		}
-	}
-	fn parity(&self)->bool{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)
-			|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)
-	}
-}
-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>{
-		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));
-					faces
-				};
-				let v1f={
-					let mut faces=Vec::new();
-					self.mesh1.vert_faces(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);
-				self.mesh0.vert_edges(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
-					// drop faces beyond v0f_n
-					face_normals.truncate(v0f.len());
-					// make a set of faces from mesh0's perspective
-					for face_n in &v1f_n{
-						//add reflected mesh1 faces
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						f(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
-					}
-				});
-				face_normals.clone_from(&v1f_n);
-				self.mesh1.vert_edges(v1,|directed_edge_id|{
-					let n=self.mesh1.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// drop faces beyond v1f_n
-					face_normals.truncate(v1f.len());
-					// make a set of faces from mesh1's perspective
-					for face_n in &v0f_n{
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						f(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
-					}
-				});
-			},
-		}
-	}
-	fn vert_faces(&self,_vert_id:Self::Vert)->impl Iterator<Item=Self::Face>{
-		unimplemented!()
-	}
-	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={
-					let mut edges=Vec::new();
-					self.mesh0.vert_edges(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{
-						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
-						//must be behind other face.
-						let d=edge_face1_n.dot(edge0_n);
-						if d.is_negative(){
-							let edge0_nn=edge0_n.dot(edge0_n);
-							// Assume not every number is huge
-							// TODO: revisit this
-							let dd=(d*d)/(edge_face1_nn*edge0_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id0);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::VertFace(v0,edge_face_id1),
-						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
-					)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				//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));
-					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{
-						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
-						let d=edge_face0_n.dot(edge1_n);
-						if d.is_negative(){
-							let edge1_nn=edge1_n.dot(edge1_n);
-							let dd=(d*d)/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id1);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::FaceVert(edge_face_id0,v1),
-						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
-					)
-				}))
-			},
-		}
-	}
-	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)
-			),
-			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
-				MinkowskiVert::VertVert(vert_id0,v1)
-			),
-		})
-	}
-	// 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>{
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				self.mesh1.face_edges(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
-				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,|edge_id0|
-					f(MinkowskiDirectedEdge::EdgeVert(edge_id0,v1))
-				)
-			},
-		}
-	}
-}
-
-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);
-					}
-				}
-			}
-		}
-	}
-	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()]));
-}

engine/physics/src/model.rs

@@ -1,9 +1,11 @@
 use std::collections::{HashSet,HashMap};
+use core::ops::{Bound,RangeBounds};
 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};
+
+type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -12,6 +14,20 @@ 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{
+	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)]
@@ -29,13 +45,13 @@ pub struct SubmeshFaceId(u32);
 
 impl UndirectedEdge for SubmeshEdgeId{
 	type DirectedEdge=SubmeshDirectedEdgeId;
-	fn as_directed(self,parity:bool)->SubmeshDirectedEdgeId{
+	fn as_directed(&self,parity:bool)->SubmeshDirectedEdgeId{
 		SubmeshDirectedEdgeId(self.0|((parity as u32)<<(u32::BITS-1)))
 	}
 }
 impl DirectedEdge for SubmeshDirectedEdgeId{
 	type UndirectedEdge=SubmeshEdgeId;
-	fn as_undirected(self)->SubmeshEdgeId{
+	fn as_undirected(&self)->SubmeshEdgeId{
 		SubmeshEdgeId(self.0&!(1<<(u32::BITS-1)))
 	}
 	fn parity(&self)->bool{
@@ -43,6 +59,14 @@ 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{
@@ -51,6 +75,32 @@ 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
@@ -395,8 +445,9 @@ pub struct PhysicsMeshView<'a>{
 	topology:&'a PhysicsMeshTopology,
 }
 impl MeshQuery for PhysicsMeshView<'_>{
-	type Position=Planar64Vec3;
-	type Direction=Planar64Vec3;
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -424,37 +475,20 @@ 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 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 face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.topology.face_topology[face_id.get() as usize].edges.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)
-	}
-}
-impl MeshTopology for PhysicsMeshView<'_>{
-	type Face=SubmeshFaceId;
-	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 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 edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
+	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].faces)
 	}
-	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
+	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;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 vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.topology.vert_topology[vert_id.get() as usize].edges.as_slice()
+	}
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
+		self.topology.vert_topology[vert_id.get() as usize].faces.as_slice()
 	}
 }
 
@@ -494,8 +528,9 @@ impl TransformedMesh<'_>{
 	}
 }
 impl MeshQuery for TransformedMesh<'_>{
-	type Direction=Planar64Vec3;
-	type Position=Planar64Vec3;
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -523,44 +558,95 @@ 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:Self::Vert)->impl Iterator<Item=Self::DirectedEdge>{
-		self.view.vert_edges(vert_id)
+	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.view.face_edges(face_id)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:Self::Vert)->impl Iterator<Item=Self::Face>{
-		self.view.vert_faces(vert_id)
-	}
-	#[inline]
-	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
+	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
 		self.view.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
+	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;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)
-	// }
 	#[inline]
-	fn face_edges(&self,face_id:Self::Face)->impl Iterator<Item=Self::DirectedEdge>{
-		self.view.face_edges(face_id)
+	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.view.vert_edges(vert_id)
 	}
+	#[inline]
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
+		self.view.vert_faces(vert_id)
+	}
+}
+
+//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),
+}
+// 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)]
+pub enum MinkowskiEdge{
+	VertEdge(SubmeshVertId,SubmeshEdgeId),
+	EdgeVert(SubmeshEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl UndirectedEdge for MinkowskiEdge{
+	type DirectedEdge=MinkowskiDirectedEdge;
+	fn as_directed(&self,parity:bool)->Self::DirectedEdge{
+		match self{
+			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(*v0,e1.as_directed(parity)),
+			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),*v1),
+		}
+	}
+}
+#[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;
+	fn as_undirected(&self)->Self::UndirectedEdge{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
+			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
+		}
+	}
+	fn parity(&self)->bool{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(_,e)
+			|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>{
+	pub mesh0:TransformedMesh<'a>,
+	pub mesh1:TransformedMesh<'a>,
 }
 
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
@@ -568,3 +654,297 @@ pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	let r=(time-relative_to).to_ratio();
 	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{
+			mesh0,
+			mesh1,
+		}
+	}
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		//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 (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// TODO: handle unbounded collision using infinity fev
+		let time=match upper_bound{
+			Bound::Included(&time)=>time,
+			Bound::Excluded(&time)=>time,
+			Bound::Unbounded=>unimplemented!("unbounded collision out"),
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?;
+		// 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;
+		//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
+		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-relative_body.time).to_ratio());
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.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(){
+			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(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(relative_body.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)
+	}
+}
+impl MeshQuery for MinkowskiMesh<'_>{
+	type Face=MinkowskiFace;
+	type Edge=MinkowskiDirectedEdge;
+	type Vert=MinkowskiVert;
+	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.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)=>{
+				self.mesh1.face_edges(f1).as_ref().iter().map(|&edge_id1|
+					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
+				).collect()
+			},
+			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),
+				]
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				self.mesh0.face_edges(f0).as_ref().iter().map(|&edge_id0|
+					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
+				).collect()
+			},
+		}
+	}
+	fn edge_faces(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiFace;2]>{
+		match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>{
+				//faces are listed backwards from the minkowski mesh
+				let v0e=self.mesh0.vert_edges(v0);
+				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(){
+						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
+						//must be behind other face.
+						let d=edge_face1_n.dot(edge0_n);
+						if d.is_negative(){
+							let edge0_nn=edge0_n.dot(edge0_n);
+							// Assume not every number is huge
+							// TODO: revisit this
+							let dd=(d*d)/(edge_face1_nn*edge0_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id0);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::VertFace(v0,edge_face_id1),
+						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
+					)
+				}))
+			},
+			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				//tracking index with an external variable because .enumerate() is not available
+				let v1e=self.mesh1.vert_edges(v1);
+				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(){
+						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						let d=edge_face0_n.dot(edge1_n);
+						if d.is_negative(){
+							let edge1_nn=edge1_n.dot(edge1_n);
+							let dd=(d*d)/(edge_face0_nn*edge1_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id1);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::FaceVert(edge_face_id0,v1),
+						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
+					)
+				}))
+			},
+		}
+	}
+	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
+		AsRefHelper(match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
+				MinkowskiVert::VertVert(v0,vert_id1)
+			),
+			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
+				MinkowskiVert::VertVert(vert_id0,v1)
+			),
+		})
+	}
+	fn vert_edges(&self,vert_id:MinkowskiVert)->impl AsRef<[MinkowskiDirectedEdge]>{
+		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_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(){
+					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
+					// drop faces beyond v0f_n
+					face_normals.truncate(v0f.len());
+					// make a set of faces from mesh0's perspective
+					for face_n in &v1f_n{
+						//add reflected mesh1 faces
+						//wrap for speed
+						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));
+					}
+				}
+				face_normals.clone_from(&v1f_n);
+				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
+					let n=self.mesh1.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// drop faces beyond v1f_n
+					face_normals.truncate(v1f.len());
+					// make a set of faces from mesh1's perspective
+					for face_n in &v0f_n{
+						//wrap for speed
+						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));
+					}
+				}
+				edges
+			},
+		}
+	}
+	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
+		unimplemented!();
+		#[expect(unreachable_code)]
+		Vec::new()
+	}
+}
+
+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);
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+#[test]
+fn test_is_empty_volume(){
+	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()]));
+}

engine/physics/src/physics.rs

@@ -1,7 +1,5 @@
 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,PhysicsMeshId,PhysicsSubmeshId};
+use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
 use strafesnet_common::run;
@@ -17,7 +15,6 @@ pub use strafesnet_common::physics::{Time,TimeInner};
 use gameplay::ModeState;
 
 pub type Body=crate::body::Body<TimeInner>;
-pub type Trajectory=crate::body::Trajectory<TimeInner>;
 type MouseState=strafesnet_common::mouse::MouseState<TimeInner>;
 
 //external influence
@@ -31,7 +28,6 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
-	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -502,24 +498,20 @@ enum MoveState{
 }
 impl MoveState{
 	//call this after state.move_state is changed
-	fn acceleration(&self,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->Planar64Vec3{
+	fn apply_enum(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
-			MoveState::Fly=>vec3::zero(),
-			MoveState::Air
-			|MoveState::Water
-			=>{
-				// calculate base acceleration
-				let base_acceleration=touching.base_acceleration(models,style,camera,input_state);
-				// constrain_acceleration clips according to contacts
-				touching.constrain_acceleration(models,hitbox_mesh,base_acceleration)
+			MoveState::Fly=>body.acceleration=vec3::zero(),
+			MoveState::Air=>{
+				//calculate base acceleration
+				let a=touching.base_acceleration(models,style,camera,input_state);
+				//set_acceleration clips according to contacts
+				set_acceleration(body,touching,models,hitbox_mesh,a);
 			},
-			MoveState::Walk(walk_state)
-			|MoveState::Ladder(walk_state)
-			=>walk_state.target.acceleration(),
+			_=>(),
 		}
 	}
 	//function to coerce &mut self into &self
-	fn update_fly_velocity(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+	fn apply_to_body(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Air=>(),
 			MoveState::Water=>(),
@@ -529,13 +521,17 @@ impl MoveState{
 				//set_velocity clips velocity according to current touching state
 				set_velocity(body,touching,models,hitbox_mesh,v);
 			},
-			MoveState::Walk(_walk_state)
-			|MoveState::Ladder(_walk_state)
-			=>(),
+			MoveState::Walk(walk_state)
+			|MoveState::Ladder(walk_state)
+			=>{
+				//accelerate towards walk target or do nothing
+				let a=walk_state.target.acceleration();
+				set_acceleration(body,touching,models,hitbox_mesh,a);
+			},
 		}
 	}
 	/// changes the move state
-	fn update_walk_target(&mut self,body:&Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+	fn apply_input(&mut self,body:&Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Fly
 			|MoveState::Air
@@ -592,11 +588,24 @@ impl MoveState{
 			MoveState::Fly=>None,
 		}
 	}
+	//lmao idk this is convenient
+	fn apply_enum_and_input_and_body(&mut self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+		self.apply_enum(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_input(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_to_body(body,touching,models,hitbox_mesh,style,camera,input_state);
+	}
+	fn apply_enum_and_body(&mut self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+		self.apply_enum(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_to_body(body,touching,models,hitbox_mesh,style,camera,input_state);
+	}
+	fn apply_input_and_body(&mut self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+		self.apply_input(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_to_body(body,touching,models,hitbox_mesh,style,camera,input_state);
+	}
 	fn set_move_state(&mut self,move_state:MoveState,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		*self=move_state;
 		//this function call reads the above state that was just set
-		self.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-		self.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
 	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		//TODO: be more precise about contacts
@@ -609,11 +618,10 @@ impl MoveState{
 					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
-					self.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-					self.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+					self.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 				},
 				// not walking, but stopped touching something
-				None=>self.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state),
+				None=>self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state),
 			}
 		}
 	}
@@ -724,7 +732,7 @@ struct IntersectModel{
 #[derive(Debug,Clone,Copy,Hash)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
-	face_id:MinkowskiFace,
+	face_id:model_physics::MinkowskiFace,
 }
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct IntersectCollision{
@@ -736,7 +744,7 @@ pub enum Collision{
 	Intersect(IntersectCollision),
 }
 impl Collision{
-	fn new(convex_mesh_id:ConvexMeshId<PhysicsModelId>,face_id:MinkowskiFace)->Self{
+	fn new(convex_mesh_id:ConvexMeshId<PhysicsModelId>,face_id:model_physics::MinkowskiFace)->Self{
 		match convex_mesh_id.model_id{
 			PhysicsModelId::Contact(model_id)=>Collision::Contact(ContactCollision{convex_mesh_id:convex_mesh_id.map(model_id),face_id}),
 			PhysicsModelId::Intersect(model_id)=>Collision::Intersect(IntersectCollision{convex_mesh_id:convex_mesh_id.map(model_id)}),
@@ -747,7 +755,7 @@ impl Collision{
 struct TouchingState{
 	// This is kind of jank, it's a ContactCollision
 	// but split over the Key and Value of the HashMap.
-	contacts:HashMap<ConvexMeshId<ContactModelId>,MinkowskiFace>,
+	contacts:HashMap<ConvexMeshId<ContactModelId>,model_physics::MinkowskiFace>,
 	intersects:HashSet<ConvexMeshId<IntersectModelId>>,
 }
 impl TouchingState{
@@ -755,13 +763,13 @@ impl TouchingState{
 		self.contacts.clear();
 		self.intersects.clear();
 	}
-	fn insert_contact(&mut self,contact:ContactCollision)->Option<MinkowskiFace>{
+	fn insert_contact(&mut self,contact:ContactCollision)->Option<model_physics::MinkowskiFace>{
 		self.contacts.insert(contact.convex_mesh_id,contact.face_id)
 	}
 	fn insert_intersect(&mut self,intersect:IntersectCollision)->bool{
 		self.intersects.insert(intersect.convex_mesh_id)
 	}
-	fn remove_contact(&mut self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->Option<MinkowskiFace>{
+	fn remove_contact(&mut self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->Option<model_physics::MinkowskiFace>{
 		self.contacts.remove(convex_mesh_id)
 	}
 	fn remove_intersect(&mut self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
@@ -807,7 +815,7 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		crate::push_solve::push_solve(&contacts,velocity).0
+		crate::push_solve::push_solve(&contacts,velocity)
 	}
 	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:Planar64Vec3)->Planar64Vec3{
 		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
@@ -818,17 +826,18 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		crate::push_solve::push_solve(&contacts,acceleration).0
+		crate::push_solve::push_solve(&contacts,acceleration)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,trajectory:&Trajectory,start_time:Time){
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
+		let relative_body=body;
 		for (convex_mesh_id,face_id) in &self.contacts{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(convex_mesh_id);
-			let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_face_out(&trajectory,start_time..collector.time(),*face_id).map(|(_face,time)|{
+			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(),*face_id).map(|(_face,time)|{
 				TimedInstruction{
-					time:trajectory.time+time.into(),
+					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
 						Collision::Contact(ContactCollision{face_id:*face_id,convex_mesh_id:*convex_mesh_id}),
 						time
@@ -839,10 +848,10 @@ impl TouchingState{
 		for convex_mesh_id in &self.intersects{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(convex_mesh_id);
-			let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&trajectory,start_time..collector.time()).map(|(_face,time)|{
+			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
 				TimedInstruction{
-					time:trajectory.time+time.into(),
+					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
 						Collision::Intersect(IntersectCollision{convex_mesh_id:*convex_mesh_id}),
 						time
@@ -868,7 +877,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.
@@ -878,12 +886,11 @@ pub struct PhysicsState{
 impl Default for PhysicsState{
 	fn default()->Self{
  		Self{
-			body:Body::new(vec3::int(0,50,0),vec3::int(0,0,0),Time::ZERO),
+			body:Body::new(vec3::int(0,50,0),vec3::int(0,0,0),vec3::int(0,-100,0),Time::ZERO),
 			time:Time::ZERO,
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
 			move_state:MoveState::Air,
-			no_clip:false,
 			camera:PhysicsCamera::default(),
 			input_state:InputState::default(),
 			_world:WorldState{},
@@ -903,14 +910,11 @@ impl PhysicsState{
 	pub const fn body(&self)->&Body{
 		&self.body
 	}
-	pub fn camera_trajectory(&self,data:&PhysicsData)->Trajectory{
-		let acceleration=self.acceleration(data);
-		Trajectory::new(
-			self.body.position+self.style.camera_offset,
-			self.body.velocity,
-			acceleration,
-			self.body.time,
-		)
+	pub fn camera_body(&self)->Body{
+		Body{
+			position:self.body.position+self.style.camera_offset,
+			..self.body
+		}
 	}
 	pub const fn camera(&self)->PhysicsCamera{
 		self.camera
@@ -939,8 +943,8 @@ impl PhysicsState{
 	fn set_move_state(&mut self,data:&PhysicsData,move_state:MoveState){
 		self.move_state.set_move_state(move_state,&mut self.body,&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
 	}
-	fn acceleration(&self,data:&PhysicsData)->Planar64Vec3{
-		self.move_state.acceleration(&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state)
+	fn apply_input_and_body(&mut self,data:&PhysicsData){
+		self.move_state.apply_input_and_body(&mut self.body,&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
 	}
 	//state mutated on collision:
 	//Accelerator
@@ -1187,58 +1191,53 @@ impl<'a> PhysicsContext<'a>{
 	}
 }
 
-//this is the one who asks
-fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
-	//JUST POLLING!!! NO MUTATION
-	let mut collector=instruction::InstructionCollector::new(time_limit);
+	//this is the one who asks
+	fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
+		//JUST POLLING!!! NO MUTATION
+		let mut collector=instruction::InstructionCollector::new(time_limit);
 
-	collector.collect(state.next_move_instruction());
+		collector.collect(state.next_move_instruction());
 
-	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 ends
+		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
+		//check for collision starts
+		let mut aabb=aabb::Aabb::default();
+		state.body.grow_aabb(&mut aabb,state.time,collector.time());
+		aabb.inflate(data.hitbox_mesh.halfsize);
+		//relative to moving platforms
+		//let relative_body=state.body.relative_to(&Body::ZERO);
+		let relative_body=&state.body;
+		data.bvh.sample_aabb(&aabb,&mut |convex_mesh_id|{
+			if state.touching.contains(convex_mesh_id){
+				return;
+			}
+			//no checks are needed because of the time limits.
+			let model_mesh=data.models.mesh(*convex_mesh_id);
+			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
+				.map(|(face,dt)|
+					TimedInstruction{
+						time:relative_body.time+dt.into(),
+						instruction:InternalInstruction::CollisionStart(
+							Collision::new(*convex_mesh_id,face),
+							dt
+						)
+					}
+				)
+			);
+		});
+		collector.take()
 	}
 
-	//check for collision starts
-	let mut aabb=aabb::Aabb::default();
-	trajectory.grow_aabb(&mut aabb,state.time,collector.time());
-	aabb.inflate(data.hitbox_mesh.halfsize);
-	//relative to moving platforms
-	//let relative_body=state.body.relative_to(&Body::ZERO);
-	data.bvh.sample_aabb(&aabb,&mut |convex_mesh_id|{
-		if state.touching.contains(convex_mesh_id){
-			return;
-		}
-		//no checks are needed because of the time limits.
-		let model_mesh=data.models.mesh(*convex_mesh_id);
-		let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-		collector.collect(minkowski.predict_collision_in(&trajectory,state.time..collector.time())
-			.map(|(face,dt)|
-				TimedInstruction{
-					time:trajectory.time+dt.into(),
-					instruction:InternalInstruction::CollisionStart(
-						Collision::new(*convex_mesh_id,face),
-						dt
-					)
-				}
-			)
-		);
-	});
-	collector.take()
-}
-
 
 fn contact_normal(
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
 	convex_mesh_id:&ConvexMeshId<ContactModelId>,
-    face_id:MinkowskiFace,
+    face_id:model_physics::MinkowskiFace,
 )->Planar64Vec3{
 	let model_mesh=models.contact_mesh(convex_mesh_id);
-	let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+	let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 	// TODO: normalize to i64::MAX>>1
 	// wrap for speed
 	minkowski.face_nd(face_id).0.wrap_1()
@@ -1277,7 +1276,7 @@ fn recalculate_touching(
 	bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
 		//no checks are needed because of the time limits.
 		let model_mesh=models.mesh(convex_mesh_id);
-		let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 		if minkowski.contains_point(body.position){
 			match convex_mesh_id.model_id{
 				//being inside of contact objects is an invalid physics state
@@ -1336,6 +1335,24 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3){
 	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);
 }
+#[expect(dead_code)]
+fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
+	//This is not correct but is better than what I have
+	let mut culled=false;
+	touching.contacts.retain(|convex_mesh_id,face_id|{
+		let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
+		let r=n.dot(a).is_positive();
+		if r{
+			culled=true;
+		}
+		!r
+	});
+	set_acceleration(body,touching,models,hitbox_mesh,a);
+	culled
+}
+fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3){
+	body.acceleration=touching.constrain_acceleration(models,hitbox_mesh,a);
+}
 
 fn teleport(
 	point:Planar64Vec3,
@@ -1354,6 +1371,7 @@ fn teleport(
 	time:Time,
 ){
 	set_position(point,move_state,body,touching,run,mode_state,mode,models,hitbox_mesh,bvh,style,camera,input_state,time);
+	set_acceleration(body,touching,models,hitbox_mesh,style.gravity);
 }
 enum TeleportToSpawnError{
 	NoModel,
@@ -1616,8 +1634,7 @@ fn collision_start_contact(
 	}
 	//doing enum to set the acceleration when surfing
 	//doing input_and_body to refresh the walk state if you hit a wall while accelerating
-	move_state.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-	move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+	move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 }
 
 fn collision_start_intersect(
@@ -1652,20 +1669,7 @@ fn collision_start_intersect(
 			},
 			Some(gameplay_modes::Zone::Finish)=>{
 				match run.finish(time){
-					Ok(())=>{
-						let time=run.time(time);
-						let h=time.get()/(Time::ONE_SECOND.get()*60*60);
-						let m=(time.get()/(Time::ONE_SECOND.get()*60)).rem_euclid(60);
-						let s=(time.get()/(Time::ONE_SECOND.get())).rem_euclid(60);
-						let ms=(time.get()/(Time::ONE_MILLISECOND.get())).rem_euclid(1000);
-						let us=(time.get()/(Time::ONE_MICROSECOND.get())).rem_euclid(1000);
-						let ns=(time.get()/(Time::ONE_NANOSECOND.get())).rem_euclid(1000);
-						if h==0{
-							println!("@@@@ Finished run time={m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
-						}else{
-							println!("@@@@ Finished run time={h}:{m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
-						}
-					},
+					Ok(())=>println!("@@@@ Finished run time={}",run.time(time)),
 					Err(e)=>println!("@@@@ Run Finish error:{e:?}"),
 				}
 			},
@@ -1673,7 +1677,7 @@ fn collision_start_intersect(
 			None=>(),
 		}
 	}
-	move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	run_teleport_behaviour(intersect.convex_mesh_id.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
 }
 
@@ -1701,11 +1705,10 @@ fn collision_end_contact(
 			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 		}else{
 			// stopped touching something else while walking
-			move_state.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-			move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+			move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 		},
 		// not walking, but stopped touching something
-		None=>move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state),
+		None=>move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state),
 	}
 }
 fn collision_end_intersect(
@@ -1724,7 +1727,7 @@ fn collision_end_intersect(
 	time:Time,
 ){
 	touching.remove_intersect(convex_mesh_id);
-	move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(convex_mesh_id.model_id.into());
 		match zone{
@@ -1740,100 +1743,99 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	match ins.instruction{
-		// collisions advance the body precisely
+	let (should_advance_body,goober_time)=match ins.instruction{
 		InternalInstruction::CollisionStart(_,dt)
-		|InternalInstruction::CollisionEnd(_,dt)=>{
-			state.body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body_ratio_dt(dt);
-		},
-		// this advances imprecisely
-		InternalInstruction::ReachWalkTargetVelocity=>state.body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body(state.time),
-		// strafe tick decides for itself whether to advance the body.
-		InternalInstruction::StrafeTick=>(),
+		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
+		InternalInstruction::StrafeTick
+		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
+	};
+	if should_advance_body{
+		match goober_time{
+			Some(dt)=>state.body.advance_time_ratio_dt(dt),
+			None=>state.body.advance_time(state.time),
+		}
 	}
-	match ins.instruction{
-		InternalInstruction::CollisionStart(collision,_)=>{
-			let mode=data.modes.get_mode(state.mode_state.get_mode_id());
-			match collision{
-				Collision::Contact(contact)=>collision_start_contact(
-					&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,&mut state.run,
-					mode,
-					&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+		match ins.instruction{
+			InternalInstruction::CollisionStart(collision,_)=>{
+				let mode=data.modes.get_mode(state.mode_state.get_mode_id());
+				match collision{
+					Collision::Contact(contact)=>collision_start_contact(
+						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,&mut state.run,
+						mode,
+						&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+						data.models.contact_attr(contact.convex_mesh_id.model_id),
+						contact,
+						state.time,
+					),
+					Collision::Intersect(intersect)=>collision_start_intersect(
+						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,
+						mode,
+						&mut state.run,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+						data.models.intersect_attr(intersect.convex_mesh_id.model_id),
+						intersect,
+						state.time,
+					),
+				}
+			},
+			InternalInstruction::CollisionEnd(collision,_)=>match collision{
+				Collision::Contact(contact)=>collision_end_contact(
+					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.models.contact_attr(contact.convex_mesh_id.model_id),
-					contact,
-					state.time,
+					&contact.convex_mesh_id
 				),
-				Collision::Intersect(intersect)=>collision_start_intersect(
-					&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,
-					mode,
-					&mut state.run,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+				Collision::Intersect(intersect)=>collision_end_intersect(
+					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
+					data.modes.get_mode(state.mode_state.get_mode_id()),
+					&mut state.run,
 					data.models.intersect_attr(intersect.convex_mesh_id.model_id),
-					intersect,
-					state.time,
+					&intersect.convex_mesh_id,
+					state.time
 				),
-			}
-		},
-		InternalInstruction::CollisionEnd(collision,_)=>match collision{
-			Collision::Contact(contact)=>collision_end_contact(
-				&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
-				data.models.contact_attr(contact.convex_mesh_id.model_id),
-				&contact.convex_mesh_id
-			),
-			Collision::Intersect(intersect)=>collision_end_intersect(
-				&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
-				data.modes.get_mode(state.mode_state.get_mode_id()),
-				&mut state.run,
-				data.models.intersect_attr(intersect.convex_mesh_id.model_id),
-				&intersect.convex_mesh_id,
-				state.time
-			),
-		},
-		InternalInstruction::StrafeTick=>{
-			//TODO make this less huge
-			if let Some(strafe_settings)=&state.style.strafe{
-				let controls=state.input_state.controls;
-				if strafe_settings.activates(controls){
-					let masked_controls=strafe_settings.mask(controls);
-					let control_dir=state.style.get_control_dir(masked_controls);
-					if control_dir!=vec3::zero(){
-						// manually advance time
-						let extrapolated_body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body(state.time);
-						let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
-						if let Some(ticked_velocity)=strafe_settings.tick_velocity(extrapolated_body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
-							state.body=extrapolated_body;
-							//this is wrong but will work ig
-							//need to note which push planes activate in push solve and keep those
-							state.cull_velocity(data,ticked_velocity);
+			},
+			InternalInstruction::StrafeTick=>{
+				//TODO make this less huge
+				if let Some(strafe_settings)=&state.style.strafe{
+					let controls=state.input_state.controls;
+					if strafe_settings.activates(controls){
+						let masked_controls=strafe_settings.mask(controls);
+						let control_dir=state.style.get_control_dir(masked_controls);
+						if control_dir!=vec3::zero(){
+							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
+							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
+								//this is wrong but will work ig
+								//need to note which push planes activate in push solve and keep those
+								state.cull_velocity(data,ticked_velocity);
+							}
 						}
 					}
 				}
 			}
-		}
-		InternalInstruction::ReachWalkTargetVelocity=>{
-			match &mut state.move_state{
-				MoveState::Air
-				|MoveState::Water
-				|MoveState::Fly
-				=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
-				MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>{
-					//velocity is already handled by extrapolated_body
-					//we know that the acceleration is precisely zero because the walk target is known to be reachable
-					//which means that gravity can be fully cancelled
-					//ignore moving platforms for now
-					let target=core::mem::replace(&mut walk_state.target,TransientAcceleration::Reached);
-					// check what the target was to see if it was invalid
-					match target{
-						//you are not supposed to reach a walk target which is already reached!
-						TransientAcceleration::Reached=>println!("Invalid walk target: Reached"),
-						TransientAcceleration::Reachable{..}=>(),
-						//you are not supposed to reach an unreachable walk target!
-						TransientAcceleration::Unreachable{..}=>println!("Invalid walk target: Unreachable"),
+			InternalInstruction::ReachWalkTargetVelocity=>{
+				match &mut state.move_state{
+					MoveState::Air
+					|MoveState::Water
+					|MoveState::Fly
+					=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
+					MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>{
+						//velocity is already handled by advance_time
+						//we know that the acceleration is precisely zero because the walk target is known to be reachable
+						//which means that gravity can be fully cancelled
+						//ignore moving platforms for now
+						let target=core::mem::replace(&mut walk_state.target,TransientAcceleration::Reached);
+						set_acceleration(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::zero());
+						// check what the target was to see if it was invalid
+						match target{
+							//you are not supposed to reach a walk target which is already reached!
+							TransientAcceleration::Reached=>println!("Invalid walk target: Reached"),
+							TransientAcceleration::Reachable{..}=>(),
+							//you are not supposed to reach an unreachable walk target!
+							TransientAcceleration::Unreachable{..}=>println!("Invalid walk target: Unreachable"),
+						}
 					}
 				}
-			}
-		},
+			},
+		}
 	}
-}
 
 fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<Instruction,Time>){
 	state.time=ins.time;
@@ -1859,7 +1861,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Misc(MiscInstruction::PracticeFly)=>true,
 	};
 	if should_advance_body{
-		state.body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body(state.time);
+		state.body.advance_time(state.time);
 	}
 
 	let mut b_refresh_walk_target=true;
@@ -1895,10 +1897,6 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			state.input_state.set_control(Controls::Zoom,s);
 			b_refresh_walk_target=false;
 		},
-		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
 			state.reset_to_default();
@@ -1958,8 +1956,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 	}
 	if b_refresh_walk_target{
-		state.move_state.update_walk_target(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state);
-		state.move_state.update_fly_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state);
+		state.apply_input_and_body(data);
 		state.cull_velocity(data,state.body.velocity);
 		//also check if accelerating away from surface
 	}
@@ -1969,16 +1966,16 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 mod test{
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};
 	use super::*;
-	fn test_collision_axis_aligned(relative_body:Trajectory,expected_collision_time:Option<Time>){
+	fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
 		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),integer::Planar64Affine3::new(mat3::from_diagonal(int3(5,1,5)>>1),vec3::zero()));
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
-		let minkowski=MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,..);
+		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
-	fn test_collision_rotated(relative_body:Trajectory,expected_collision_time:Option<Time>){
+	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
 		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),
 			integer::Planar64Affine3::new(
 				Planar64Mat3::from_cols([
@@ -1992,17 +1989,17 @@ mod test{
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
-		let minkowski=MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,..);
+		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
-	fn test_collision(relative_body:Trajectory,expected_collision_time:Option<Time>){
+	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
 		test_collision_axis_aligned(relative_body,expected_collision_time);
 		test_collision_rotated(relative_body,expected_collision_time);
 	}
 	#[test]
 	fn test_collision_degenerate_straight_down(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2011,7 +2008,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_small_mv(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0)+(vec3::X>>32),
 			vec3::zero(),
@@ -2020,7 +2017,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_east(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(3,5,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2029,7 +2026,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_south(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,3),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2038,7 +2035,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_west(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-3,5,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2047,7 +2044,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_north(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,-3),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2056,115 +2053,115 @@ mod test{
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_west(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(3,3,0),
 			int3(100,-1,0),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_north(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,3,3),
 			int3(0,-1,100),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_east(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-3,3,0),
 			int3(-100,-1,0),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_south(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,3,-3),
 			int3(0,-1,-100),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_ne(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,-7)>>1,
 			int3(-10,-1,1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_nw(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,-7)>>1,
 			int3(10,-1,1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_se(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(7,6,0)>>1,
 			int3(-1,-1,-10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_ne(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(7,6,0)>>1,
 			int3(-1,-1,10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_se(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,7)>>1,
 			int3(-10,-1,-1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_sw(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,7)>>1,
 			int3(10,-1,-1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_se(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-7,6,0)>>1,
 			int3(1,-1,-10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_ne(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-7,6,0)>>1,
 			int3(1,-1,10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_oblique(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,0),
 			int3(1,-64,2)>>6,// /64
 			vec3::zero(),
@@ -2173,7 +2170,7 @@ mod test{
 	}
 	#[test]
 	fn zoom_hit_nothing(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,10,0),
 			int3(1,0,0),
 			int3(0,1,0),
@@ -2182,7 +2179,7 @@ mod test{
 	}
 	#[test]
 	fn already_inside_hit_nothing(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			vec3::zero(),
 			int3(1,0,0),
 			int3(0,1,0),
@@ -2192,7 +2189,7 @@ mod test{
 	// overlap edges by 1 epsilon
 	#[test]
 	fn almost_miss_north(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)+vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2201,7 +2198,7 @@ mod test{
 	}
 	#[test]
 	fn almost_miss_east(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)+vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2210,7 +2207,7 @@ mod test{
 	}
 	#[test]
 	fn almost_miss_south(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)+vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2219,7 +2216,7 @@ mod test{
 	}
 	#[test]
 	fn almost_miss_west(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)+vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2229,7 +2226,7 @@ mod test{
 	// exactly miss edges
 	#[test]
 	fn exact_miss_north(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(0,10,-7)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2238,7 +2235,7 @@ mod test{
 	}
 	#[test]
 	fn exact_miss_east(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(7,10,0)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2247,7 +2244,7 @@ mod test{
 	}
 	#[test]
 	fn exact_miss_south(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(0,10,7)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2256,7 +2253,7 @@ mod test{
 	}
 	#[test]
 	fn exact_miss_west(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(-7,10,0)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2266,7 +2263,7 @@ mod test{
 	// miss edges by 1 epsilon
 	#[test]
 	fn narrow_miss_north(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)-vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2275,7 +2272,7 @@ mod test{
 	}
 	#[test]
 	fn narrow_miss_east(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)-vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2284,7 +2281,7 @@ mod test{
 	}
 	#[test]
 	fn narrow_miss_south(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)-vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2293,7 +2290,7 @@ mod test{
 	}
 	#[test]
 	fn narrow_miss_west(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)-vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),

engine/physics/src/push_solve.rs

@@ -15,7 +15,6 @@ type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
 const RATIO_ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
 
 /// Information about a contact restriction
-#[derive(Debug,PartialEq)]
 pub struct Contact{
 	pub position:Planar64Vec3,
 	pub velocity:Planar64Vec3,
@@ -282,16 +281,16 @@ fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ra
 		.min_by_key(|&(t,_)|t)
 }
 
-pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->(Planar64Vec3,Conts<'_>){
+pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
 	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
 	loop{
 		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){
 			Some((t,cont))=>(t,cont),
-			None=>return (ray.origin,conts),
+			None=>return ray.origin,
 		};
 
 		if RATIO_ZERO.le_ratio(next_t){
-			return (ray.origin,conts);
+			return ray.origin;
 		}
 
 		//push_front
@@ -307,7 +306,7 @@ pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->(Planar64Vec3,Conts<'
 		let meet_point=ray.extrapolate(next_t);
 		match get_best_push_ray_and_conts(meet_point,conts.as_slice()){
 			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
-			None=>return (meet_point,conts),
+			None=>return meet_point,
 		}
 	}
 }
@@ -324,8 +323,9 @@ mod tests{
 				normal:vec3::Y,
 			}
 		];
-		let (point,conts)=push_solve(&contacts,vec3::NEG_Y);
-		assert_eq!(point,vec3::zero());
-		assert_eq!(conts.as_slice(),[&contacts[0]].as_slice());
+		assert_eq!(
+			vec3::zero(),
+			push_solve(&contacts,vec3::NEG_Y)
+		);
 	}
 }

engine/session/src/session.rs

@@ -57,7 +57,7 @@ pub enum SessionPlaybackInstruction{
 }
 
 pub struct FrameState{
-	pub trajectory:physics::Trajectory,
+	pub body:physics::Body,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
 }
@@ -76,9 +76,9 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime,data:&PhysicsData)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
 		FrameState{
-			trajectory:self.physics.camera_trajectory(data),
+			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
 		}
@@ -187,9 +187,9 @@ impl Session{
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time,&self.geometry_shared)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time,&self.geometry_shared)
+				replay.simulation.get_frame_state(time)
 			),
 		}
 	}
@@ -238,16 +238,12 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Restart(mode_id)));
-				// TODO: think about this harder.  This works around a bug where you fall infinitely when you reset.
-				self.simulation.timer.set_time(ins.time,PhysicsTime::ZERO);
 			},
 			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(mode_id,spawn_id)))=>{
 				self.clear_recording();
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Spawn(mode_id,spawn_id)));
-				// TODO: think about this harder.  This works around a bug where you fall infinitely when you reset.
-				self.simulation.timer.set_time(ins.time,PhysicsTime::ZERO);
 			},
 			Instruction::Input(SessionInputInstruction::Misc(misc_instruction))=>{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(misc_instruction));

integration-testing/src/main.rs

@@ -71,16 +71,16 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 	for (i,ins) in bot.instructions.into_iter().enumerate(){
 		let state_deterministic=physics_deterministic.clone();
 		let state_filtered=physics_filtered.clone();
-		PhysicsContext::run_input_instruction(&mut physics_deterministic,physics_data,ins.clone());
+		PhysicsContext::run_input_instruction(&mut physics_deterministic,&physics_data,ins.clone());
 		match ins{
 			strafesnet_common::instruction::TimedInstruction{instruction:strafesnet_common::physics::Instruction::Idle,..}=>(),
 			other=>{
 				non_idle_count+=1;
 				// run
-				PhysicsContext::run_input_instruction(&mut physics_filtered,physics_data,other.clone());
+				PhysicsContext::run_input_instruction(&mut physics_filtered,&physics_data,other.clone());
 				// check if position matches
-				let b0=physics_deterministic.camera_trajectory(physics_data);
-				let b1=physics_filtered.camera_trajectory(physics_data);
+				let b0=physics_deterministic.camera_body();
+				let b1=physics_filtered.camera_body();
 				if b0.position!=b1.position{
 					let nanoseconds=start.elapsed().as_nanos() as u64;
 					println!("desync at instruction #{}",i);

integration-testing/src/test_scenes.rs

@@ -73,6 +73,7 @@ fn simultaneous_collision(){
 	let body=strafesnet_physics::physics::Body::new(
 		(vec3::int(5+2,0,0)>>1)+vec3::int(1,1,0),
 		vec3::int(-1,-1,0),
+		vec3::int(0,0,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -87,6 +88,7 @@ fn simultaneous_collision(){
 	let body=physics.body();
 	assert_eq!(body.position,vec3::int(5,0,0));
 	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(1));
 }
 #[test]
@@ -95,6 +97,7 @@ fn bug_3(){
 	let body=strafesnet_physics::physics::Body::new(
 		(vec3::int(5+2,0,0)>>1)+vec3::int(1,2,0),
 		vec3::int(-1,-1,0),
+		vec3::int(0,0,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -109,5 +112,6 @@ fn bug_3(){
 	let body=physics.body();
 	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
 	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }

integration-testing/src/tests.rs

@@ -22,6 +22,7 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	let body=strafesnet_physics::physics::Body::new(
 		vec3::raw_xyz(555690659654,1490485868773,1277783839382),
 		vec3::int(0,0,0),
+		vec3::int(0,-100,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -59,12 +60,9 @@ fn physics_bug_3()->Result<(),ReplayError>{
 		// vec3::raw_xyz(0,-96915585363,1265),
 		// vec3::raw_xyz(0,-429496729600,0),
 		// corner setup before wall hits
-		// vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
-		// vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
-		// vec3::raw_xyz(0,-429496729600,0),
-		// Actual bug 3 repro
-		vec3::raw_xyz(-2505538624455,3357963283914,557275711118),
-		vec3::raw_xyz(204188283920,-282280474198,166172785440),
+		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
+		vec3::raw_xyz(0,-429496729600,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);

lib/common/src/physics.rs

@@ -36,7 +36,6 @@ pub enum SetControlInstruction{
 	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
-	SetSprint(bool),
 }
 #[derive(Clone,Debug)]
 pub enum ModeInstruction{

lib/snf/src/newtypes/physics.rs

@@ -88,11 +88,6 @@ pub enum Instruction{
 	PracticeFly,
 	#[brw(magic=14u8)]
 	SetSensitivity(super::integer::Ratio64Vec2),
-	#[brw(magic=15u8)]
-	SetSprint(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
 	#[brw(magic=255u8)]
 	Idle,
 }
@@ -121,7 +116,6 @@ impl TryInto<strafesnet_common::physics::Instruction> for Instruction{
 			Instruction::SetMoveForward(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state.into())),
 			Instruction::SetJump(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state.into())),
 			Instruction::SetZoom(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state.into())),
-			Instruction::SetSprint(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetSprint(state.into())),
 			Instruction::Reset=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset),
 			Instruction::Restart(mode_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(strafesnet_common::gameplay_modes::ModeId::new(mode_id))),
 			Instruction::Spawn(mode_id,stage_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(
@@ -148,7 +142,6 @@ impl TryFrom<strafesnet_common::physics::Instruction> for Instruction{
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state))=>Ok(Instruction::SetMoveForward(state.into())),
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state))=>Ok(Instruction::SetJump(state.into())),
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state))=>Ok(Instruction::SetZoom(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetSprint(state))=>Ok(Instruction::SetSprint(state.into())),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset)=>Ok(Instruction::Reset),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(mode_id))=>Ok(Instruction::Restart(mode_id.get())),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(mode_id,stage_id))=>Ok(Instruction::Spawn(

strafe-client/src/window.rs

@@ -138,7 +138,6 @@ impl WindowContext<'_>{
 
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Shift)=>input_ctrl!(SetSprint,s),
 							// TODO: bind system so playback pausing can use spacebar
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>if s{
 								let paused=!self.simulation_paused;