expect two events

Cargo.lock

@@ -1974,9 +1974,9 @@ dependencies = [
 
 [[package]]
 name = "luau0-src"
-version = "0.17.0+luau701"
+version = "0.15.11+luau697"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed8f8edd8aba9654a9eeb62b2fe7461589f2faf2d0a1bc04bd64c0123319b3fc"
+checksum = "bdbf698d77af7b846fab212ca666c5d597b9ff445ef1a647e181d3392e13dfdf"
 dependencies = [
  "cc",
 ]
@@ -2149,13 +2149,12 @@ dependencies = [
 
 [[package]]
 name = "mlua"
-version = "0.11.5"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "935ac67539907efcd7198137eb7358e052555f77fe1b2916600a2249351f2b33"
+checksum = "9be1c2bfc684b8a228fbaebf954af7a47a98ec27721986654a4cc2c40a20cc7e"
 dependencies = [
  "bstr",
  "either",
- "libc",
  "mlua-sys",
  "num-traits",
  "parking_lot",
@@ -2165,9 +2164,9 @@ dependencies = [
 
 [[package]]
 name = "mlua-sys"
-version = "0.9.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c968af21bf6b19fc9ca8e7b85ee16f86e4c9e3d0591de101a5608086bda0ad8"
+checksum = "3d4dc9cfc5a7698899802e97480617d9726f7da78c910db989d4d0fd4991d900"
 dependencies = [
  "cc",
  "cfg-if",
@@ -3815,7 +3814,6 @@ dependencies = [
  "arrayvec",
  "glam",
  "id",
- "mlua",
  "strafesnet_common",
 ]
 

engine/physics/Cargo.toml

@@ -7,7 +7,6 @@ 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

@@ -33,7 +33,7 @@ impl<T:Copy> std::ops::Neg for &Body<T>{
 impl<T> Body<T>
 	where Time<T>:Copy,
 {
-	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),vec3::zero(),Time::ZERO);
+	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{
 		Self{
 			position,
@@ -107,8 +107,8 @@ impl<T> Body<T>
 		self.time+=dt.into();
 	}
 	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
-		if self.velocity==vec3::zero(){
-			if self.acceleration==vec3::zero(){
+		if self.velocity==vec3::ZERO{
+			if self.acceleration==vec3::ZERO{
 				None
 			}else{
 				Some(self.acceleration)

engine/physics/src/lib.rs

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

engine/physics/src/minimum_difference.rs

@@ -1,648 +0,0 @@
-use strafesnet_common::integer::vec3;
-use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::integer::{Fixed,Planar64Vec3};
-
-use crate::model::{MeshQuery,MinkowskiMesh,MinkowskiVert};
-
-// This algorithm is based on Lua code
-// written by Trey Reynolds in 2021
-
-type Simplex<const N:usize>=[MinkowskiVert;N];
-enum Simplex1_3{
-	Simplex1(Simplex<1>),
-	Simplex2(Simplex<2>),
-	Simplex3(Simplex<3>),
-}
-impl Simplex1_3{
-	fn push_front(self,v:MinkowskiVert)->Simplex2_4{
-		match self{
-			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
-			Simplex1_3::Simplex2([v0,v1])=>Simplex2_4::Simplex3([v,v0,v1]),
-			Simplex1_3::Simplex3([v0,v1,v2])=>Simplex2_4::Simplex4([v,v0,v1,v2]),
-		}
-	}
-}
-enum Simplex2_4{
-	Simplex2(Simplex<2>),
-	Simplex3(Simplex<3>),
-	Simplex4(Simplex<4>),
-}
-
-/*
-local function absDet(r, u, v, w)
-	if w then
-		return math.abs((u - r):Cross(v - r):Dot(w - r))
-	elseif v then
-		return (u - r):Cross(v - r).magnitude
-	elseif u then
-		return (u - r).magnitude
-	else
-		return 1
-	end
-end
-*/
-impl Simplex2_4{
-	fn det_is_zero(&self,mesh:&MinkowskiMesh)->bool{
-		match self{
-			&Self::Simplex4([p0,p1,p2,p3])=>{
-				let p0=mesh.vert(p0);
-				let p1=mesh.vert(p1);
-				let p2=mesh.vert(p2);
-				let p3=mesh.vert(p3);
-				(p1-p0).cross(p2-p0).dot(p3-p0)==Fixed::ZERO
-			},
-			&Self::Simplex3([p0,p1,p2])=>{
-				let p0=mesh.vert(p0);
-				let p1=mesh.vert(p1);
-				let p2=mesh.vert(p2);
-				(p1-p0).cross(p2-p0)==vec3::zero()
-			},
-			&Self::Simplex2([p0,p1])=>{
-				let p0=mesh.vert(p0);
-				let p1=mesh.vert(p1);
-				p1-p0==vec3::zero()
-			}
-		}
-	}
-}
-
-/*
-local function choosePerpendicularDirection(d)
-	local x, y, z = d.x, d.y, d.z
-	local best = math.min(x*x, y*y, z*z)
-	if x*x == best then
-		return Vector3.new(y*y + z*z, -x*y, -x*z)
-	elseif y*y == best then
-		return Vector3.new(-x*y, x*x + z*z, -y*z)
-	else
-		return Vector3.new(-x*z, -y*z, x*x + y*y)
-	end
-end
-*/
-fn choose_perpendicular_direction(d:Planar64Vec3)->Planar64Vec3{
-	let x=d.x.abs();
-	let y=d.y.abs();
-	let z=d.z.abs();
-	if x<y&&x<z{
-		Vector3::new([Fixed::ZERO,-d.z,d.y])
-	}else if y<z{
-		Vector3::new([d.z,Fixed::ZERO,-d.x])
-	}else{
-		Vector3::new([-d.y,d.x,Fixed::ZERO])
-	}
-}
-
-const fn choose_any_direction()->Planar64Vec3{
-	vec3::X
-}
-
-fn reduce1(
-	[v0]:Simplex<1>,
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-)->Reduced{
-	// --debug.profilebegin("reduceSimplex0")
-	// local a = a1 - a0
-	let p0=-mesh.vert(v0);
-
-	// local p = -a
-	let p=-(p0+point);
-
-	// local direction = p
-	let mut dir=p;
-
-	// if direction.magnitude == 0 then
-	// 	direction = chooseAnyDirection()
-	if dir==vec3::zero(){
-		dir=choose_any_direction();
-	}
-
-	// return direction, a0, a1
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2(
-	[v0,v1]:Simplex<2>,
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-)->Reduced{
-	// --debug.profilebegin("reduceSimplex1")
-	// local a = a1 - a0
-	// local b = b1 - b0
-	let p0=-mesh.vert(v0);
-	let p1=-mesh.vert(v1);
-
-	// local p = -a
-	// local u = b - a
-	let p=-(p0+point);
-	let u=p1-p0;
-
-	// -- modify to take into account the radiuses
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = u:Cross(p):Cross(u)
-		let direction=u.cross(p).cross(u);
-
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			return Reduced{
-				dir:choose_perpendicular_direction(u),
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			};
-		}
-
-		// -- modify the direction to take into account a0R and b0R
-		// return direction, a0, a1, b0, b1
-		return Reduced{
-			dir:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		};
-	}
-
-	// local direction = p
-	let mut dir=p;
-
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		dir=choose_perpendicular_direction(u);
-	}
-
-	// return direction, a0, a1
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3(
-	[v0,mut v1,v2]:Simplex<3>,
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-)->Reduced{
-	// --debug.profilebegin("reduceSimplex2")
-	// local a = a1 - a0
-	// local b = b1 - b0
-	// local c = c1 - c0
-	let p0=-mesh.vert(v0);
-	let p1=-mesh.vert(v1);
-	let p2=-mesh.vert(v2);
-
-	// local p = -a
-	// local u = b - a
-	// local v = c - a
-	let p=-(p0+point);
-	let mut u=p1-p0;
-	let v=p2-p0;
-
-	// local uv = u:Cross(v)
-	// local up = u:Cross(p)
-	// local pv = p:Cross(v)
-	// local uv_up = uv:Dot(up)
-	// local uv_pv = uv:Dot(pv)
-	let mut uv=u.cross(v);
-	let mut up=u.cross(p);
-	let pv=p.cross(v);
-	let uv_up=uv.dot(up);
-	let uv_pv=uv.dot(pv);
-
-	// if uv_up >= 0 and uv_pv >= 0 then
-	if !uv_up.is_negative()&&!uv_pv.is_negative(){
-		// local uvp = uv:Dot(p)
-		let uvp=uv.dot(p);
-
-		// local direction = uvp < 0 and -uv or uv
-		let direction=if uvp.is_negative(){
-			-uv
-		}else{
-			uv
-		};
-
-		// return direction, a0, a1, b0, b1, c0, c1
-		return Reduced{
-			dir:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		};
-	}
-
-	// local u_u = u:Dot(u)
-	// local v_v = v:Dot(v)
-	// local uDist = uv_up/(u_u*v.magnitude)
-	// local vDist = uv_pv/(v_v*u.magnitude)
-	// local minDist2 = math.min(uDist, vDist)
-	let u_dist=uv_up*v.length();
-	let v_dist=uv_pv*u.length();
-
-	// if vDist == minDist2 then
-	if v_dist<u_dist{
-		u=v;
-		up=-pv;
-		uv=-uv;
-		// b0 = c0
-		// b1 = c1
-		v1=v2;
-	}
-
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = up:Cross(u)
-		let direction=up.cross(u);
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			// direction = uv
-			return Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			};
-		}
-
-		// return direction, a0, a1, b0, b1
-		return Reduced{
-			dir:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		};
-	}
-
-	// local direction = p
-	let dir=p;
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		// direction = uv
-		return Reduced{
-			dir:uv.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex1([v0]),
-		};
-	}
-	// return direction, a0, a0
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4(
-	[v0,mut v1,mut v2,v3]:Simplex<4>,
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-)->Reduce{
-	// --debug.profilebegin("reduceSimplex3")
-	// local a = a1 - a0
-	// local b = b1 - b0
-	// local c = c1 - c0
-	// local d = d1 - d0
-	let p0=-mesh.vert(v0);
-	let p1=-mesh.vert(v1);
-	let p2=-mesh.vert(v2);
-	let p3=-mesh.vert(v3);
-
-	// local p = -a
-	// local u = b - a
-	// local v = c - a
-	// local w = d - a
-	let p=-(p0+point);
-	let mut u=p1-p0;
-	let mut v=p2-p0;
-	let w=p3-p0;
-
-	// local uv = u:Cross(v)
-	// local vw = v:Cross(w)
-	// local wu = w:Cross(u)
-	// local uvw = uv:Dot(w)
-	// local pvw = vw:Dot(p)
-	// local upw = wu:Dot(p)
-	// local uvp = uv:Dot(p)
-	let mut uv=u.cross(v);
-	let vw=v.cross(w);
-	let wu=w.cross(u);
-	let uv_w=uv.dot(w);
-	let pv_w=vw.dot(p);
-	let up_w=wu.dot(p);
-	let uv_p=uv.dot(p);
-
-	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
-	if !pv_w.div_sign(uv_w).is_negative()
-	 ||!up_w.div_sign(uv_w).is_negative()
-	 ||!uv_p.div_sign(uv_w).is_negative(){
-		// origin is contained, this is a positive detection
-		// local direction = Vector3.new(0, 0, 0)
-		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
-		return Reduce::Escape([v0,v1,v2,v3]);
-	}
-
-	// local uvwSign = uvw < 0 and -1 or uvw > 0 and 1 or 0
-	// local uvDist = uvp*uvwSign/uv.magnitude
-	// local vwDist = pvw*uvwSign/vw.magnitude
-	// local wuDist = upw*uvwSign/wu.magnitude
-	// local minDist3 = math.min(uvDist, vwDist, wuDist)
-	let uv_dist=uv_p.mul_sign(uv_w);
-	let vw_dist=pv_w.mul_sign(uv_w);
-	let wu_dist=up_w.mul_sign(uv_w);
-	let wu_len=wu.length();
-	let uv_len=uv.length();
-	let vw_len=vw.length();
-
-	if vw_dist*wu_len<wu_dist*vw_len{
-		// if vwDist == minDist3 then
-		if vw_dist*uv_len<uv_dist*vw_len{
-			(u,v)=(v,w);
-			uv=vw;
-			// uv_p=pv_w; // unused
-			// b0, c0 = c0, d0
-			// b1, c1 = c1, d1
-			(v1,v2)=(v2,v3);
-		}else{
-			v2=v3;
-		}
-	}else{
-		// elseif wuDist == minDist3 then
-		if wu_dist*uv_len<uv_dist*wu_len{
-			(u,v)=(w,u);
-			uv=wu;
-			// uv_p=up_w; // unused
-			// b0, c0 = d0, b0
-			// b1, c1 = d1, b1
-			// before [a,b,c,d]
-			(v1,v2)=(v3,v1);
-			// after [a,d,b]
-		}else{
-			v2=v3;
-		}
-	}
-
-	// local up = u:Cross(p)
-	// local pv = p:Cross(v)
-	// local uv_up = uv:Dot(up)
-	// local uv_pv = uv:Dot(pv)
-	let mut up=u.cross(p);
-	let pv=p.cross(v);
-	let uv_up=uv.dot(up);
-	let uv_pv=uv.dot(pv);
-
-	// if uv_up >= 0 and uv_pv >= 0 then
-	if !uv_up.is_negative()&&!uv_pv.is_negative(){
-		// local direction = uvw < 0 and uv or -uv
-		// return direction, a0, a1, b0, b1, c0, c1
-		if uv_w.is_negative(){
-			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
-		}else{
-			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
-		}
-	}
-
-	// local u_u = u:Dot(u)
-	// local v_v = v:Dot(v)
-	// local uDist = uv_up/(u_u*v.magnitude)
-	// local vDist = uv_pv/(v_v*u.magnitude)
-	// local minDist2 = math.min(uDist, vDist)
-	let u_dist=uv_up*v.length();
-	let v_dist=uv_pv*u.length();
-
-	// if vDist == minDist2 then
-	if v_dist<u_dist{
-		u=v;
-		up=-pv;
-		uv=-uv;
-		// b0 = c0
-		// b1 = c1
-		v1=v2;
-	}
-
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = up:Cross(u)
-		let direction=up.cross(u);
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			// direction = uvw < 0 and uv or -uv
-			// return direction, a0, a1, b0, b1
-			if uv_w.is_negative(){
-				return Reduce::Reduced(Reduced{
-					dir:uv.narrow_1().unwrap(),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
-			}else{
-				return Reduce::Reduced(Reduced{
-					dir:-uv.narrow_1().unwrap(),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
-			}
-		}
-
-		// return direction, a0, a1, b0, b1
-		return Reduce::Reduced(Reduced{
-			dir:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		});
-	}
-
-	// local direction = p
-	let dir=p;
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		// direction = uvw < 0 and uv or -uv
-		if uv_w.is_negative(){
-			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
-		}else{
-			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
-		}
-	}
-
-	// return direction, a0, a1
-	Reduce::Reduced(Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	})
-}
-
-struct Reduced{
-	dir:Planar64Vec3,
-	simplex:Simplex1_3,
-}
-
-enum Reduce{
-	Escape(Simplex<4>),
-	Reduced(Reduced),
-}
-
-impl Simplex2_4{
-	fn reduce(self,mesh:&MinkowskiMesh,point:Planar64Vec3)->Reduce{
-		match self{
-			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
-			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
-			Self::Simplex4(simplex)=>reduce4(simplex,mesh,point),
-		}
-	}
-}
-
-// local function expand(
-// 	queryP, queryQ,
-// 	vertA0, vertA1,
-// 	vertB0, vertB1,
-// 	vertC0, vertC1,
-// 	vertD0, vertD1,
-// 	accuracy
-// )
-fn refine_to_exact(mesh:&MinkowskiMesh,simplex:Simplex<4>)->Simplex2_4{
-	unimplemented!()
-}
-
-/// Intermediate data structure containing a partially complete calculation.
-/// Sometimes you only care about the topology, and not about the
-/// exact point of intersection details.
-pub struct Topology{
-	simplex:Simplex2_4,
-}
-impl Topology{
-	/// Returns None if the point is intersecting the mesh.
-	pub fn closest_point_details(self,mesh:&MinkowskiMesh)->Option<Details>{
-		// NOTE: if hits is true, this if statement necessarily evaluates to true.
-		// i.e. hits implies this statement
-		// if -dist <= exitRadius + radiusP + radiusQ then
-		// 	local posP, posQ = decompose(-point, a0, a1, b0, b1, c0, c1)
-		// 	return hits, -dist - radiusP - radiusQ,
-		// 		posP - radiusP*norm, -norm,
-		// 		posQ + radiusQ*norm, norm
-		// end
-		// return false
-		unimplemented!()
-	}
-}
-pub struct Details{
-	// distance:Planar64,
-	// p_pos:Planar64Vec3,
-	// p_norm:Planar64Vec3,
-	// q_pos:Planar64Vec3,
-	// q_norm:Planar64Vec3,
-}
-
-pub fn contains_point(mesh:&MinkowskiMesh,point:Planar64Vec3)->bool{
-	const ENABLE_FAST_FAIL:bool=true;
-	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
-		// on_exact
-		|last_pos,direction|{
-			// local norm = direction.unit
-			// local dist = a:Dot(norm)
-			// local hits = -dist < radiusP + radiusQ
-			// return hits
-			(last_pos+point).dot(direction).is_positive()
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			true
-		},
-		// fast_fail value
-		||false
-	)
-}
-pub fn closest_fev(mesh:&MinkowskiMesh,point:Planar64Vec3)->Topology{
-	const ENABLE_FAST_FAIL:bool=false;
-	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
-		// on_exact
-		|_last_pos,_direction|unimplemented!(),
-		// on_escape
-		|simplex|{
-			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
-			let simplex=refine_to_exact(mesh,simplex);
-			Topology{simplex}
-		},
-		// fast_fail value is irrelevant and will never be returned!
-		||unreachable!()
-	)
-}
-
-// local function minimumDifference(
-// 	queryP, radiusP,
-// 	queryQ, radiusQ,
-// 	exitRadius, testIntersection
-// )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-	on_exact:impl FnOnce(Planar64Vec3,Planar64Vec3)->T,
-	on_escape:impl FnOnce(Simplex<4>)->T,
-	on_fast_fail:impl FnOnce()->T,
-)->T{
-	// local initialAxis = queryQ() - queryP()
-	// local new_point_p = queryP(initialAxis)
-	// local new_point_q = queryQ(-initialAxis)
-	// local direction, a0, a1, b0, b1, c0, c1, d0, d1
-	let mut initial_axis=-mesh.hint_point()+point;
-	// degenerate case
-	if initial_axis==vec3::zero(){
-		initial_axis=choose_any_direction();
-	}
-	let last_point=mesh.farthest_vert(direction);
-	// this represents the 'a' value in the commented code
-	let mut last_pos=-mesh.vert(last_point);
-	let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);
-
-	// exitRadius = testIntersection and 0 or exitRadius or 1/0
-	// for _ = 1, 100 do
-	loop{
-		// new_point_p = queryP(-direction)
-		// new_point_q = queryQ(direction)
-		// local next_point = new_point_q - new_point_p
-		let next_point=mesh.farthest_vert(-direction);
-		let next_pos=-mesh.vert(next_point);
-
-		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
-		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
-			return on_fast_fail();
-		}
-
-		let simplex_big=simplex_small.push_front(next_point);
-
-		// 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){
-			// Found enough information to compute the exact closest point.
-			return on_exact(last_pos,direction);
-		}
-
-		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
-		match simplex_big.reduce(mesh,point){
-			// if a and b and c and d then
-			Reduce::Escape(simplex)=>{
-				// Enough information to conclude that the meshes are intersecting.
-				// Topology information is computed if needed.
-				return on_escape(simplex);
-			},
-			Reduce::Reduced(reduced)=>{
-				direction=reduced.dir;
-				simplex_small=reduced.simplex;
-			},
-		}
-
-		// next loop this will be a
-		last_pos=next_pos;
-	}
-}

engine/physics/src/minimum_difference_lua.rs

@@ -1,159 +0,0 @@
-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,Details)>{
-	let md=minimum_difference(mesh,point,false)?;
-	Ok((md.hits,md.details.unwrap()))
-}
-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(),
-				}),
-			}),
-			values=>Err(mlua::Error::runtime(format!("Invalid return values: {values:?}"))),
-		}
-	}
-}
-
-struct Args{
-	query_p:Function,
-	radius_p:f64,
-	query_q:Function,
-	radius_q:f64,
-	exit_radius: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;
-		let exit_radius=0.0;
-		// Query the farthest point on the mesh in the given direction.
-		let query_p=lua.create_function(move|_,dir:Option<Vector>|{
-			let Some(dir)=dir else{
-				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,
-			exit_radius,
-			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)?,
-			self.exit_radius.into_lua(lua)?,
-			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/game/src/ReplicatedStorage/Shared/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/model.rs

@@ -90,8 +90,6 @@ pub trait MeshQuery{
 		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 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]>;
@@ -449,10 +447,6 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let face_idx=self.topology.faces[face_id.get() as usize].get() as usize;
 		(self.data.faces[face_idx].normal,self.data.faces[face_idx].dot)
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		// invariant: meshes always encompass the origin
-		vec3::zero()
-	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
@@ -509,7 +503,7 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
-	pub fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
 			self.view.topology.verts.iter()
@@ -538,9 +532,6 @@ impl MeshQuery for TransformedMesh<'_>{
 		// wrap for speed
 		self.transform.vertex.transform_point3(self.view.vert(vert_id)).wrap_1()
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.transform.vertex.translation
-	}
 	#[inline]
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
@@ -567,7 +558,7 @@ impl MeshQuery for TransformedMesh<'_>{
 //(face,vertex)
 //(edge,edge)
 //(vertex,face)
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
@@ -586,7 +577,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -619,8 +610,8 @@ pub enum MinkowskiFace{
 
 #[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
-	pub mesh0:TransformedMesh<'a>,
-	pub mesh1:TransformedMesh<'a>,
+	mesh0:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
 }
 
 //infinity fev algorithm state transition
@@ -647,7 +638,7 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	pub fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
 		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
 	}
 	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
@@ -759,9 +750,24 @@ impl MinkowskiMesh<'_>{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
-			infinity_body.acceleration=vec3::zero();
+			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
+			match infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time){
+				// This is the expected case.
+				// We expect to never hit the mesh while setting up for the real crawl
+				// since the algorithm breaks down on the inside of the mesh.
+				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
+				// An exact hit is allowed, it has not crossed the boundary.
+				crate::face_crawler::CrawlResult::Hit(face,ratio)=>match start_time{
+					Bound::Included(_)=>ratio.num.is_zero().then(||FEV::Face(face)),
+					// You are looking for collision events within a range that does not include the start_time.
+					// The boundary is crossed at exactly start_time, so the range is not met.
+					// Therefore, the correct return value is None.
+					Bound::Excluded(_)=>unimplemented!(),
+					// To infinity and beyond!
+					Bound::Unbounded=>None,
+				},
+			}
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
@@ -810,11 +816,20 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge
 	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		let contains_point_lua=crate::minimum_difference_lua::contains_point(self,point).unwrap();
-		let contains_point=crate::minimum_difference::contains_point(self,point);
-		println!("contains_point={contains_point} contains_point_lua={contains_point_lua}");
-		contains_point
+	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
+		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
+		// Bound::Included means that the surface of the mesh is included in the mesh
+		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
+	}
+	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
+		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
+		//movement must escape the mesh forwards and backwards in time,
+		//otherwise the point is not inside the mesh
+		self.infinity_in(infinity_body)
+    	.is_some_and(|_|
+			self.infinity_in(-infinity_body)
+    		.is_some()
+     	)
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -853,9 +868,6 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
-	}
 	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{

engine/physics/src/physics.rs

@@ -28,6 +28,7 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
+	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -113,11 +114,11 @@ struct ContactMoveState{
 }
 impl TransientAcceleration{
 	fn with_target_diff(target_diff:Planar64Vec3,accel:Planar64,time:Time)->Self{
-		if target_diff==vec3::zero(){
+		if target_diff==vec3::ZERO{
 			TransientAcceleration::Reached
 		}else if accel==Planar64::ZERO{
 			TransientAcceleration::Unreachable{
-				acceleration:vec3::zero()
+				acceleration:vec3::ZERO
 			}
 		}else{
 			//normal friction acceleration is clippedAcceleration.dot(normal)*friction
@@ -140,7 +141,7 @@ impl TransientAcceleration{
 	}
 	fn acceleration(&self)->Planar64Vec3{
 		match self{
-			TransientAcceleration::Reached=>vec3::zero(),
+			TransientAcceleration::Reached=>vec3::ZERO,
 			&TransientAcceleration::Reachable{acceleration,time:_}=>acceleration,
 			&TransientAcceleration::Unreachable{acceleration}=>acceleration,
 		}
@@ -443,7 +444,7 @@ impl StyleHelper for StyleModifiers{
 
 	fn get_control_dir(&self,controls:Controls)->Planar64Vec3{
 		//don't get fancy just do it
-		let mut control_dir:Planar64Vec3=vec3::zero();
+		let mut control_dir:Planar64Vec3=vec3::ZERO;
 		//Apply mask after held check so you can require non-allowed keys to be held for some reason
 		let controls=controls.intersection(self.controls_mask);
 		if controls.contains(Controls::MoveForward){
@@ -482,7 +483,7 @@ impl StyleHelper for StyleModifiers{
 		};
 		let transform=integer::Planar64Affine3::new(
 			mat3::from_diagonal(self.hitbox.halfsize),
-			vec3::zero()
+			vec3::ZERO
 		);
 		HitboxMesh::new(mesh,transform)
 	}
@@ -500,7 +501,7 @@ impl MoveState{
 	//call this after state.move_state is changed
 	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=>body.acceleration=vec3::zero(),
+			MoveState::Fly=>body.acceleration=vec3::ZERO,
 			MoveState::Air=>{
 				//calculate base acceleration
 				let a=touching.base_acceleration(models,style,camera,input_state);
@@ -614,7 +615,7 @@ impl MoveState{
 			// TODO: unduplicate this code
 			match self.get_walk_state(){
 				// did you stop touching the thing you were walking on?
-				Some(walk_state)=>if !touching.contains_contact(&walk_state.contact.convex_mesh_id){
+				Some(walk_state)=>if !touching.contacts.contains_key(&walk_state.contact.convex_mesh_id){
 					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
@@ -753,8 +754,6 @@ impl Collision{
 }
 #[derive(Clone,Debug,Default)]
 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>,model_physics::MinkowskiFace>,
 	intersects:HashSet<ConvexMeshId<IntersectModelId>>,
 }
@@ -775,16 +774,10 @@ impl TouchingState{
 	fn remove_intersect(&mut self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
 		self.intersects.remove(convex_mesh_id)
 	}
-	fn contains_contact(&self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->bool{
-		self.contacts.contains_key(convex_mesh_id)
-	}
-	fn contains_intersect(&self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
-		self.intersects.contains(convex_mesh_id)
-	}
 	fn contains(&self,convex_mesh_id:&ConvexMeshId<PhysicsModelId>)->bool{
 		match convex_mesh_id.model_id{
-			PhysicsModelId::Contact(contact_model_id)=>self.contains_contact(&convex_mesh_id.map(contact_model_id)),
-			PhysicsModelId::Intersect(intersect_model_id)=>self.contains_intersect(&convex_mesh_id.map(intersect_model_id)),
+			PhysicsModelId::Contact(contact_model_id)=>self.contacts.contains_key(&convex_mesh_id.map(contact_model_id)),
+			PhysicsModelId::Intersect(intersect_model_id)=>self.intersects.contains(&convex_mesh_id.map(intersect_model_id)),
 		}
 	}
 	fn base_acceleration(&self,models:&PhysicsModels,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->Planar64Vec3{
@@ -810,7 +803,7 @@ impl TouchingState{
 		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
 			let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
 			crate::push_solve::Contact{
-				position:vec3::zero(),
+				position:vec3::ZERO,
 				velocity:n,
 				normal:n,
 			}
@@ -821,7 +814,7 @@ impl TouchingState{
 		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
 			let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
 			crate::push_solve::Contact{
-				position:vec3::zero(),
+				position:vec3::ZERO,
 				velocity:n,
 				normal:n,
 			}
@@ -835,7 +828,7 @@ impl TouchingState{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(convex_mesh_id);
 			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)|{
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..=collector.time(),*face_id).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -849,7 +842,7 @@ impl TouchingState{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(convex_mesh_id);
 			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)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..=collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -1196,7 +1189,7 @@ impl<'a> PhysicsContext<'a>{
 		//JUST POLLING!!! NO MUTATION
 		let mut collector=instruction::InstructionCollector::new(time_limit);
 
-		collector.collect(state.next_move_instruction());
+		// collector.collect(state.next_move_instruction());
 
 		//check for collision ends
 		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
@@ -1214,7 +1207,7 @@ impl<'a> PhysicsContext<'a>{
 			//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())
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..=collector.time())
 				.map(|(face,dt)|
 					TimedInstruction{
 						time:relative_body.time+dt.into(),
@@ -1277,7 +1270,7 @@ fn recalculate_touching(
 		//no checks are needed because of the time limits.
 		let model_mesh=models.mesh(convex_mesh_id);
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-		if minkowski.contains_point(body.position){
+		if minkowski.is_point_in_mesh(body.position){
 			match convex_mesh_id.model_id{
 				//being inside of contact objects is an invalid physics state
 				//but the physics isn't advanced enough to do anything about it yet
@@ -1572,7 +1565,7 @@ fn collision_start_contact(
 				//kill v
 				//actually you could do this with a booster attribute :thinking:
 				//it's a little bit different because maybe you want to chain ladders together
-				set_velocity(body,touching,models,hitbox_mesh,vec3::zero());//model.velocity
+				set_velocity(body,touching,models,hitbox_mesh,vec3::ZERO);//model.velocity
 			}
 			//ladder walkstate
 			let (gravity,target_velocity)=ladder_things(ladder_settings,&contact,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1743,17 +1736,14 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	let (should_advance_body,goober_time)=match ins.instruction{
+	match ins.instruction{
+		// collisions advance the body precisely
 		InternalInstruction::CollisionStart(_,dt)
-		|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),
-		}
+		|InternalInstruction::CollisionEnd(_,dt)=>state.body.advance_time_ratio_dt(dt),
+		// this advances imprecisely
+		InternalInstruction::ReachWalkTargetVelocity=>state.body.advance_time(state.time),
+		// strafe tick decides for itself whether to advance the body.
+		InternalInstruction::StrafeTick=>(),
 	}
 		match ins.instruction{
 			InternalInstruction::CollisionStart(collision,_)=>{
@@ -1799,7 +1789,9 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					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(){
+						if control_dir!=vec3::ZERO{
+							// manually advance time
+							state.body.advance_time(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(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
@@ -1822,7 +1814,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						//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());
+						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!
@@ -1904,7 +1896,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 		Instruction::Mode(ModeInstruction::Restart(mode_id))=>{
 			//teleport to mode start zone
-			let mut spawn_point=vec3::zero();
+			let mut spawn_point=vec3::ZERO;
 			let mode=data.modes.get_mode(mode_id);
 			if let Some(mode)=mode{
 				// set style
@@ -1917,7 +1909,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 				}
 			}
 			set_position(spawn_point,&mut state.move_state,&mut state.body,&mut state.touching,&mut state.run,&mut state.mode_state,mode,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,state.time);
-			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::zero());
+			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
 			state.set_move_state(data,MoveState::Air);
 			b_refresh_walk_target=false;
 		}
@@ -1967,7 +1959,7 @@ mod test{
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};
 	use super::*;
 	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 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();
@@ -1983,7 +1975,7 @@ mod test{
 					int3(0,1,0)>>1,
 					int3(-1,0,5)>>1,
 				]),
-				vec3::zero()
+				vec3::ZERO
 			),
 		);
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
@@ -2002,7 +1994,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2011,7 +2003,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0)+(vec3::X>>32),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2020,7 +2012,7 @@ mod test{
 		test_collision(Body::new(
 			int3(3,5,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2029,7 +2021,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,3),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2038,7 +2030,7 @@ mod test{
 		test_collision(Body::new(
 			int3(-3,5,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2047,7 +2039,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,-3),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2164,7 +2156,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,0),
 			int3(1,-64,2)>>6,// /64
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2180,7 +2172,7 @@ mod test{
 	#[test]
 	fn already_inside_hit_nothing(){
 		test_collision(Body::new(
-			vec3::zero(),
+			vec3::ZERO,
 			int3(1,0,0),
 			int3(0,1,0),
 			Time::ZERO
@@ -2192,7 +2184,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)+vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2201,7 +2193,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)+vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2210,7 +2202,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)+vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2219,7 +2211,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)+vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2229,7 +2221,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(0,10,-7)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2238,7 +2230,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(7,10,0)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2247,7 +2239,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(0,10,7)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2256,7 +2248,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(-7,10,0)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2266,7 +2258,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)-vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2275,7 +2267,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)-vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2284,7 +2276,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)-vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2293,7 +2285,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)-vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}

engine/physics/src/push_solve.rs

@@ -39,18 +39,20 @@ impl Contact{
 
 //note that this is horrible with fixed point arithmetic
 fn solve1(c0:&Contact)->Option<Ratio<Vector3<Fixed<3,96>>,Fixed<2,64>>>{
+	const EPSILON:Fixed<2,64>=Fixed::from_bits(Fixed::<2,64>::ONE.to_bits().shr(10));
 	let det=c0.normal.dot(c0.velocity);
-	if det.abs()==Fixed::ZERO{
+	if det.abs()<EPSILON{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
 	Some(c0.normal*d0/det)
 }
 fn solve2(c0:&Contact,c1:&Contact)->Option<Ratio<Vector3<Fixed<5,160>>,Fixed<4,128>>>{
+	const EPSILON:Fixed<4,128>=Fixed::from_bits(Fixed::<4,128>::ONE.to_bits().shr(10));
 	let u0_u1=c0.velocity.cross(c1.velocity);
 	let n0_n1=c0.normal.cross(c1.normal);
 	let det=u0_u1.dot(n0_n1);
-	if det.abs()==Fixed::ZERO{
+	if det.abs()<EPSILON{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
@@ -58,9 +60,10 @@ fn solve2(c0:&Contact,c1:&Contact)->Option<Ratio<Vector3<Fixed<5,160>>,Fixed<4,1
 	Some((c1.normal.cross(u0_u1)*d0+u0_u1.cross(c0.normal)*d1)/det)
 }
 fn solve3(c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ratio<Vector3<Fixed<4,128>>,Fixed<3,96>>>{
+	const EPSILON:Fixed<3,96>=Fixed::from_bits(Fixed::<3,96>::ONE.to_bits().shr(10));
 	let n0_n1=c0.normal.cross(c1.normal);
 	let det=c2.normal.dot(n0_n1);
-	if det.abs()==Fixed::ZERO{
+	if det.abs()<EPSILON{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
@@ -146,7 +149,7 @@ fn is_space_enclosed_4(
 }
 
 const fn get_push_ray_0(point:Planar64Vec3)->Ray{
-	Ray{origin:point,direction:vec3::zero()}
+	Ray{origin:point,direction:vec3::ZERO}
 }
 fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
 	//wrap for speed
@@ -318,13 +321,13 @@ mod tests{
 	fn test_push_solve(){
 		let contacts=vec![
 			Contact{
-				position:vec3::zero(),
+				position:vec3::ZERO,
 				velocity:vec3::Y,
 				normal:vec3::Y,
 			}
 		];
 		assert_eq!(
-			vec3::zero(),
+			vec3::ZERO,
 			push_solve(&contacts,vec3::NEG_Y)
 		);
 	}

integration-testing/src/test_scenes.rs

@@ -77,7 +77,7 @@ fn simultaneous_collision(){
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
-	physics.style_mut().gravity=vec3::zero();
+	physics.style_mut().gravity=vec3::ZERO;
 	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(2))
 		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
 	// the order that they hit does matter, but we aren't currently worrying about that.
@@ -101,12 +101,14 @@ fn bug_3(){
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
-	physics.style_mut().gravity=vec3::zero();
+	physics.style_mut().gravity=vec3::ZERO;
 	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(3))
 		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
 	// touch side of part at 0,0,0
 	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
-	// touch top of part at 5,-5,0
+	// EXPECTED: touch top of part at 5,-5,0
+	// OBSERVED: CollisionEnd part at 0,0,0; clip through part at 5,-5,0
+	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
 	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
 	assert!(phys_iter.next().is_none());
 	let body=physics.body();

lib/bsp_loader/src/brush.rs

@@ -210,7 +210,7 @@ pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	let color=mb.acquire_color_id(glam::Vec4::ONE);
 	let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
 	// normals are ignored by physics
-	let normal=mb.acquire_normal_id(integer::vec3::zero());
+	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
 
 	let polygon_list=faces.into_iter().map(|face|{
 		face.into_iter().map(|pos|{

lib/bsp_loader/src/bsp.rs

@@ -105,7 +105,7 @@ pub fn convert<'a>(
 					water:Some(attr::IntersectingWater{
 						viscosity:integer::Planar64::ONE,
 						density:integer::Planar64::ONE,
-						velocity:integer::vec3::zero(),
+						velocity:integer::vec3::ZERO,
 					}),
 				},
 				general:attr::GeneralAttributes::default(),
@@ -295,7 +295,7 @@ pub fn convert<'a>(
 					attributes,
 					transform:integer::Planar64Affine3::new(
 						integer::mat3::identity(),
-						integer::vec3::zero(),
+						integer::vec3::ZERO,
 					),
 					color:glam::Vec4::ONE,
 				});

lib/common/src/gameplay_style.rs

@@ -319,7 +319,7 @@ impl WalkSettings{
 		self.accelerate.accel.min((-gravity.y*friction).clamp_1())
 	}
 	pub fn get_walk_target_velocity(&self,control_dir:Planar64Vec3,normal:Planar64Vec3)->Planar64Vec3{
-		if control_dir==crate::integer::vec3::zero(){
+		if control_dir==crate::integer::vec3::ZERO{
 			return control_dir;
 		}
 		let nn=normal.length_squared();
@@ -329,13 +329,13 @@ impl WalkSettings{
 		let dd=d*d;
 		if dd<nnmm{
 			let cr=normal.cross(control_dir);
-			if cr==crate::integer::vec3::zero(){
-				crate::integer::vec3::zero()
+			if cr==crate::integer::vec3::ZERO_2{
+				crate::integer::vec3::ZERO
 			}else{
 				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
-			crate::integer::vec3::zero()
+			crate::integer::vec3::ZERO
 		}
 	}
 	pub fn is_slope_walkable(&self,normal:Planar64Vec3,up:Planar64Vec3)->bool{
@@ -360,7 +360,7 @@ impl LadderSettings{
 		self.accelerate.accel
 	}
 	pub fn get_ladder_target_velocity(&self,mut control_dir:Planar64Vec3,normal:Planar64Vec3)->Planar64Vec3{
-		if control_dir==crate::integer::vec3::zero(){
+		if control_dir==crate::integer::vec3::ZERO{
 			return control_dir;
 		}
 		let nn=normal.length_squared();
@@ -382,13 +382,13 @@ impl LadderSettings{
 		//- fix the underlying issue
 		if dd<nnmm{
 			let cr=normal.cross(control_dir);
-			if cr==crate::integer::vec3::zero(){
-				crate::integer::vec3::zero()
+			if cr==crate::integer::vec3::ZERO_2{
+				crate::integer::vec3::ZERO
 			}else{
 				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
-			crate::integer::vec3::zero()
+			crate::integer::vec3::ZERO
 		}
 	}
 }

lib/common/src/integer.rs

@@ -561,6 +561,12 @@ pub mod vec3{
 	pub use linear_ops::types::Vector3;
 	pub const MIN:Planar64Vec3=Planar64Vec3::new([Planar64::MIN;3]);
 	pub const MAX:Planar64Vec3=Planar64Vec3::new([Planar64::MAX;3]);
+	pub const ZERO:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO;3]);
+	pub const ZERO_2:Vector3<Fixed::<2,64>>=Vector3::new([Fixed::<2,64>::ZERO;3]);
+	pub const ZERO_3:Vector3<Fixed::<3,96>>=Vector3::new([Fixed::<3,96>::ZERO;3]);
+	pub const ZERO_4:Vector3<Fixed::<4,128>>=Vector3::new([Fixed::<4,128>::ZERO;3]);
+	pub const ZERO_5:Vector3<Fixed::<5,160>>=Vector3::new([Fixed::<5,160>::ZERO;3]);
+	pub const ZERO_6:Vector3<Fixed::<6,192>>=Vector3::new([Fixed::<6,192>::ZERO;3]);
 	pub const X:Planar64Vec3=Planar64Vec3::new([Planar64::ONE,Planar64::ZERO,Planar64::ZERO]);
 	pub const Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ONE,Planar64::ZERO]);
 	pub const Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::ONE]);
@@ -569,10 +575,6 @@ pub mod vec3{
 	pub const NEG_Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::NEG_ONE,Planar64::ZERO]);
 	pub const NEG_Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::NEG_ONE]);
 	pub const NEG_ONE:Planar64Vec3=Planar64Vec3::new([Planar64::NEG_ONE,Planar64::NEG_ONE,Planar64::NEG_ONE]);
-	// TODO: use #![feature(generic_const_items)] when stabilized https://github.com/rust-lang/rust/issues/113521
-	pub const fn zero<const N:usize,const F:usize>()->Vector3<Fixed<N,F>>{
-		Vector3::new([Fixed::ZERO;3])
-	}
 	#[inline]
 	pub const fn int(x:i32,y:i32,z:i32)->Planar64Vec3{
 		Planar64Vec3::new([Planar64::raw((x as i64)<<32),Planar64::raw((y as i64)<<32),Planar64::raw((z as i64)<<32)])
@@ -661,7 +663,7 @@ pub struct Planar64Affine3{
 	pub translation:Planar64Vec3,
 }
 impl Planar64Affine3{
-	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::zero());
+	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::ZERO);
 	#[inline]
 	pub const fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
 		Self{matrix3,translation}

lib/fixed_wide/src/fixed.rs

@@ -70,34 +70,6 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn midpoint(self,other:Self)->Self{
 		Self::from_bits(self.bits.midpoint(other.bits))
 	}
-	#[inline]
-	pub const fn min(self,other:Self)->Self{
-		Self::from_bits(self.bits.min(other.bits))
-	}
-	#[inline]
-	pub const fn max(self,other:Self)->Self{
-		Self::from_bits(self.bits.max(other.bits))
-	}
-	/// return the result of self*sign(other)
-	#[inline]
-	pub const fn mul_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else if other.is_zero(){
-			Fixed::ZERO
-		}else{
-			self
-		}
-	}
-	/// return the result of self/sign(other) (divide by zero does not change the sign)
-	#[inline]
-	pub const fn div_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else{
-			self
-		}
-	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it

lib/rbx_loader/src/rbx.rs

@@ -251,7 +251,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}
 	}
 	//need some way to skip this
-	if allow_booster&&velocity!=vec3::zero(){
+	if allow_booster&&velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
 	Ok(match force_can_collide{

lib/rbx_loader/src/union.rs

@@ -250,7 +250,7 @@ pub fn convert(
 		// generate a unit cube as default physics
 		let pos_list=CUBE_DEFAULT_VERTICES.map(|pos|mb.acquire_pos_id(pos>>1));
 		let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
-		let normal=mb.acquire_normal_id(vec3::zero());
+		let normal=mb.acquire_normal_id(vec3::ZERO);
 		let color=mb.acquire_color_id(glam::Vec4::ONE);
 		let polygon_group=PolygonGroup::PolygonList(PolygonList::new(CUBE_DEFAULT_POLYS.map(|poly|poly.map(|[pos_id,_]|
 			mb.acquire_vertex_id(IndexedVertex{pos:pos_list[pos_id as usize],tex,normal,color})