not dead code

these were supposed to be 3 voxels but were on the order of 3 units

engine/graphics/Cargo.toml

@@ -11,7 +11,7 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "27.0.0"
+wgpu = "28.0.0"
 
 [lints]
 workspace = true

engine/graphics/src/graphics.rs

@@ -616,7 +616,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::ClampToEdge,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
 			..Default::default()
 		});
 		let repeat_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
@@ -626,7 +626,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::Repeat,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
 			anisotropy_clamp:16,
 			..Default::default()
 		});
@@ -754,7 +754,7 @@ impl GraphicsState{
 				&skybox_texture_bind_group_layout,
 				&model_bind_group_layout,
 			],
-			push_constant_ranges:&[],
+			immediate_size:0,
 		});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
@@ -762,7 +762,7 @@ impl GraphicsState{
 				&camera_bind_group_layout,
 				&skybox_texture_bind_group_layout,
 			],
-			push_constant_ranges:&[],
+			immediate_size:0,
 		});
 
 		// Create the render pipelines
@@ -793,7 +793,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview:None,
+			multiview_mask:None,
 			cache:None,
 		});
 		let model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
@@ -828,7 +828,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview:None,
+			multiview_mask:None,
 			cache:None,
 		});
 
@@ -880,7 +880,7 @@ impl GraphicsState{
 			camera_buf,
 			models:Vec::new(),
 			depth_view,
-			staging_belt:wgpu::util::StagingBelt::new(0x100),
+			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
 			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
@@ -918,7 +918,6 @@ impl GraphicsState{
 				&self.camera_buf,
 				0,
 				wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
-				device,
 			)
 			.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
 		//This code only needs to run when the uniforms change
@@ -965,6 +964,7 @@ impl GraphicsState{
 				}),
 				timestamp_writes:Default::default(),
 				occlusion_query_set:Default::default(),
+				multiview_mask:None,
 			});
 
 			rpass.set_bind_group(0,&self.bind_groups.camera,&[]);

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.velocity==vec3::zero(){
-			if self.acceleration==vec3::ZERO{
+			if self.acceleration==vec3::zero(){
 				None
 			}else{
 				Some(self.acceleration)

engine/physics/src/face_crawler.rs

@@ -21,12 +21,6 @@ impl<M:MeshQuery> CrawlResult<M>{
 			CrawlResult::Hit(face,time)=>Some((face,time)),
 		}
 	}
-	pub fn miss(self)->Option<FEV<M>>{
-		match self{
-			CrawlResult::Miss(fev)=>Some(fev),
-			CrawlResult::Hit(_,_)=>None,
-		}
-	}
 }
 
 // TODO: move predict_collision_face_out algorithm in here or something

engine/physics/src/lib.rs

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

engine/physics/src/minimum_difference.rs

@@ -0,0 +1,913 @@
+use strafesnet_common::integer::vec3;
+use strafesnet_common::integer::vec3::Vector3;
+use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
+
+use crate::model::{DirectedEdge,FEV,MeshQuery};
+// TODO: remove mesh invert
+use crate::model::{MinkowskiMesh,MinkowskiVert};
+
+// This algorithm is based on Lua code
+// written by Trey Reynolds in 2021
+
+type Simplex<const N:usize,Vert>=[Vert;N];
+#[derive(Clone,Copy)]
+enum Simplex1_3<Vert>{
+	Simplex1(Simplex<1,Vert>),
+	Simplex2(Simplex<2,Vert>),
+	Simplex3(Simplex<3,Vert>),
+}
+impl<Vert> Simplex1_3<Vert>{
+	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
+		match self{
+			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
+			Simplex1_3::Simplex2([v0,v1])=>Simplex2_4::Simplex3([v,v0,v1]),
+			Simplex1_3::Simplex3([v0,v1,v2])=>Simplex2_4::Simplex4([v,v0,v1,v2]),
+		}
+	}
+}
+#[derive(Clone,Copy)]
+enum Simplex2_4<Vert>{
+	Simplex2(Simplex<2,Vert>),
+	Simplex3(Simplex<3,Vert>),
+	Simplex4(Simplex<4,Vert>),
+}
+
+/*
+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<Vert> Simplex2_4<Vert>{
+	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);
+				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 narrow_dir2(dir:Vector3<Fixed<2,64>>)->Planar64Vec3{
+	if dir==vec3::zero(){
+		return dir.narrow_1().unwrap();
+	}
+	let x=dir.x.as_bits().unsigned_abs().bits();
+	let y=dir.y.as_bits().unsigned_abs().bits();
+	let z=dir.z.as_bits().unsigned_abs().bits();
+	let big=x.max(y).max(z);
+	const MAX_BITS:u32=64+31;
+	if MAX_BITS<big{
+		dir>>(big-MAX_BITS)
+	}else{
+		dir
+	}.narrow_1().unwrap()
+}
+fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
+	if dir==vec3::zero(){
+		return dir.narrow_1().unwrap();
+	}
+	let x=dir.x.as_bits().unsigned_abs().bits();
+	let y=dir.y.as_bits().unsigned_abs().bits();
+	let z=dir.z.as_bits().unsigned_abs().bits();
+	let big=x.max(y).max(z);
+	const MAX_BITS:u32=96+31;
+	if MAX_BITS<big{
+		dir>>(big-MAX_BITS)
+	}else{
+		dir
+	}.narrow_1().unwrap()
+}
+
+fn reduce1<M:MeshQuery>(
+	[v0]:Simplex<1,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduced<M::Vert>{
+	// --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<M:MeshQuery>(
+	[v0,v1]:Simplex<2,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduced<M::Vert>{
+	// --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:narrow_dir3(direction),
+			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<M:MeshQuery>(
+	[v0,mut v1,v2]:Simplex<3,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduced<M::Vert>{
+	// --debug.profilebegin("reduceSimplex2")
+	// local a = a1 - a0
+	// local b = b1 - b0
+	// local c = c1 - c0
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+	let p2=mesh.vert(v2);
+
+	// 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:narrow_dir2(direction),
+			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:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex2([v0,v1]),
+			};
+		}
+
+		// return direction, a0, a1, b0, b1
+		return Reduced{
+			dir:narrow_dir3(direction),
+			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:narrow_dir2(uv),
+			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<M:MeshQuery>(
+	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
+	mesh:&M,
+	point:Planar64Vec3,
+)->Reduce<M::Vert>{
+	// --debug.profilebegin("reduceSimplex3")
+	// local a = a1 - a0
+	// local b = b1 - b0
+	// local c = c1 - c0
+	// local d = d1 - d0
+	let p0=mesh.vert(v0);
+	let p1=mesh.vert(v1);
+	let p2=mesh.vert(v2);
+	let p3=mesh.vert(v3);
+
+	// 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:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}else{
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				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:narrow_dir2(uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}else{
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(-uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
+		}
+
+		// return direction, a0, a1, b0, b1
+		return Reduce::Reduced(Reduced{
+			dir:narrow_dir3(direction),
+			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:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}else{
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
+	}
+
+	// return direction, a0, a1
+	Reduce::Reduced(Reduced{
+		dir,
+		simplex:Simplex1_3::Simplex1([v0]),
+	})
+}
+
+struct Reduced<Vert>{
+	dir:Planar64Vec3,
+	simplex:Simplex1_3<Vert>,
+}
+
+enum Reduce<Vert>{
+	Escape(Simplex<4,Vert>),
+	Reduced(Reduced<Vert>),
+}
+
+impl<Vert> Simplex2_4<Vert>{
+	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
+		match self{
+			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
+			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
+			Self::Simplex4(simplex)=>reduce4(simplex,mesh,point),
+		}
+	}
+}
+
+pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+	const ENABLE_FAST_FAIL:bool=true;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+		// on_exact
+		|is_intersecting,_simplex|{
+			is_intersecting
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			true
+		},
+		// fast_fail value
+		||false
+	)
+}
+
+//infinity fev algorithm state transition
+#[derive(Debug)]
+enum Transition<Vert>{
+	Done,//found closest vert, no edges are better
+	Vert(Vert),//transition to vert
+}
+enum EV<M:MeshQuery>{
+	Vert(M::Vert),
+	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+}
+impl<M:MeshQuery> From<EV<M>> for FEV<M>{
+	fn from(value:EV<M>)->Self{
+		match value{
+			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
+			EV::Edge(minkowski_edge)=>FEV::Edge(minkowski_edge),
+		}
+	}
+}
+
+trait Contains{
+	fn contains(&self,point:Planar64Vec3)->bool;
+}
+
+// convenience type to check if a point is within some threshold of a plane.
+struct ThickPlane{
+	point:Planar64Vec3,
+	normal:Vector3<Fixed<2,64>>,
+	epsilon:Fixed<3,96>,
+}
+impl ThickPlane{
+	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+		let p0=mesh.vert(v0);
+		let p1=mesh.vert(v1);
+		let p2=mesh.vert(v2);
+		let point=p0;
+		let normal=(p1-p0).cross(p2-p0);
+		// Allow ~ 2*sqrt(3) units of thickness on the plane
+		// This is to account for the variance of two voxels across the longest diagonal
+		let epsilon=(normal.length()*(Planar64::EPSILON*3)).wrap_3();
+		Self{point,normal,epsilon}
+	}
+}
+impl Contains for ThickPlane{
+	fn contains(&self,point:Planar64Vec3)->bool{
+		(point-self.point).dot(self.normal).abs()<=self.epsilon
+	}
+}
+
+struct ThickLine{
+	point:Planar64Vec3,
+	dir:Planar64Vec3,
+	epsilon:Fixed<4,128>,
+}
+impl ThickLine{
+	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+		let p0=mesh.vert(v0);
+		let p1=mesh.vert(v1);
+		let point=p0;
+		let dir=p1-p0;
+		// Allow ~ 2*sqrt(3) units of thickness on the plane
+		// This is to account for the variance of two voxels across the longest diagonal
+		let epsilon=(dir.length_squared()*(Planar64::EPSILON*3)).widen_4();
+		Self{point,dir,epsilon}
+	}
+}
+impl Contains for ThickLine{
+	fn contains(&self,point:Planar64Vec3)->bool{
+		(point-self.point).cross(self.dir).length_squared()<=self.epsilon
+	}
+}
+
+struct EVFinder<'a,M,C>{
+	mesh:&'a M,
+	constraint:C,
+	best_distance_squared:Fixed<2,64>,
+}
+
+impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
+	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
+		let mut best_transition=Transition::Done;
+		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
+			//test if this edge's opposite vertex closer
+			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
+			//select opposite vertex
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			let test_pos=self.mesh.vert(test_vert_id);
+			let diff=point-test_pos;
+			let distance_squared=diff.dot(diff);
+			// ensure test_vert_id is coplanar to simplex
+			if distance_squared<self.best_distance_squared&&self.constraint.contains(test_pos){
+				best_transition=Transition::Vert(test_vert_id);
+				self.best_distance_squared=distance_squared;
+			}
+		}
+		best_transition
+	}
+	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
+		let mut best_transition=EV::Vert(vert_id);
+		let vert_pos=self.mesh.vert(vert_id);
+		let diff=point-vert_pos;
+		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
+			//test if this edge is closer
+			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			let test_pos=self.mesh.vert(test_vert_id);
+			let edge_n=test_pos-vert_pos;
+			let d=edge_n.dot(diff);
+			//test the edge
+			let edge_nn=edge_n.dot(edge_n);
+			// ensure edge contains closest point and directed_edge_id is coplanar to simplex
+			if !d.is_negative()&&d<=edge_nn&&self.constraint.contains(test_pos){
+				let distance_squared={
+					let c=diff.cross(edge_n);
+					//wrap for speed
+					(c.dot(c)/edge_nn).divide().wrap_2()
+				};
+				if distance_squared<=self.best_distance_squared{
+					best_transition=EV::Edge(directed_edge_id.as_undirected());
+					self.best_distance_squared=distance_squared;
+				}
+			}
+		}
+		best_transition
+	}
+	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
+		loop{
+			match self.next_transition_vert(vert_id,point){
+				Transition::Done=>return self.final_ev(vert_id,point),
+				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
+			}
+		}
+	}
+}
+/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
+fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
+	// naively start at the closest vertex
+	// the closest vertex is not necessarily the one with the fewest boundary hops
+	// but it doesn't matter, we will get there regardless.
+	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
+		let diff=point-mesh.vert(vert_id);
+		(vert_id,diff.dot(diff))
+	}).min_by_key(|&(_,d)|d).unwrap();
+
+	let constraint=ThickLine::new(mesh,simplex);
+	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
+	//start on any vertex
+	//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
+	//cross edge-face boundary if it's uncrossable
+	finder.crawl_boundaries(vert_id,point)
+}
+
+/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
+fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiVert>,point:Planar64Vec3)->FEV::<MinkowskiMesh<'a>>{
+	// naively start at the closest vertex
+	// the closest vertex is not necessarily the one with the fewest boundary hops
+	// but it doesn't matter, we will get there regardless.
+	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
+		let diff=point-mesh.vert(vert_id);
+		(vert_id,diff.dot(diff))
+	}).min_by_key(|&(_,d)|d).unwrap();
+
+	let constraint=ThickPlane::new(mesh,simplex);
+	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
+	//start on any vertex
+	//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
+	//cross edge-face boundary if it's uncrossable
+	match finder.crawl_boundaries(vert_id,point){
+		//if a vert is returned, it is the closest point to the infinity point
+		EV::Vert(vert_id)=>FEV::Vert(vert_id),
+		EV::Edge(edge_id)=>{
+			//cross to face if we are on the wrong side
+			let edge_n=mesh.edge_n(edge_id);
+			// point is multiplied by two because vert_sum sums two vertices.
+			let delta_pos=point*2-{
+				let &[v0,v1]=mesh.edge_verts(edge_id).as_ref();
+				mesh.vert(v0)+mesh.vert(v1)
+			};
+			for (i,&face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
+				//test if this face is closer
+				let (face_n,d)=mesh.face_nd(face_id);
+				//if test point is behind face, the face is invalid
+				// TODO: find out why I thought of this backwards
+				if !(face_n.dot(point)-d).is_positive(){
+					continue;
+				}
+				//edge-face boundary nd, n facing out of the face towards the edge
+				let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
+				let boundary_d=boundary_n.dot(delta_pos);
+				//is test point behind edge, i.e. contained in the face
+				if !boundary_d.is_positive(){
+					//both faces cannot pass this condition, return early if one does.
+					return FEV::Face(face_id);
+				}
+			}
+			FEV::Edge(edge_id)
+		},
+	}
+}
+
+pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+	const ENABLE_FAST_FAIL:bool=false;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+		// on_exact
+		|is_intersecting,simplex|{
+			if is_intersecting{
+				return None;
+			}
+			// Convert simplex to FEV
+			// Vertices must be inverted since the mesh is inverted
+			Some(match simplex{
+				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
+				Simplex1_3::Simplex2([v0,v1])=>{
+					// invert
+					let (v0,v1)=(-v0,-v1);
+					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
+					if !matches!(ev,EV::Edge(_)){
+						println!("I can't believe it's not an edge!");
+					}
+					ev.into()
+				},
+				Simplex1_3::Simplex3([v0,v1,v2])=>{
+					// invert
+					let (v0,v1,v2)=(-v0,-v1,-v2);
+					// Shimmy to the side until you find a face that contains the closest point
+					// it's ALWAYS representable as a face, but this algorithm may
+					// return E or V in edge cases but I don't think that will break the face crawler
+					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
+					if !matches!(fev,FEV::Face(_)){
+						println!("I can't believe it's not a face!");
+					}
+					fev
+				},
+			})
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
+			// let simplex=refine_to_exact(mesh,simplex);
+			None
+		},
+		// 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,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{
+	// 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(-initial_axis);
+	// 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.
+			// local norm = direction.unit
+			// local dist = a:Dot(norm)
+			// local hits = -dist < radiusP + radiusQ
+			let is_intersecting=(last_pos+point).dot(direction).is_positive();
+			return on_exact(is_intersecting,simplex_small);
+		}
+
+		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
+		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;
+	}
+}
+
+#[cfg(test)]
+mod test{
+	use super::*;
+    use crate::model::{PhysicsMesh,PhysicsMeshView};
+
+    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
+		const ENABLE_FAST_FAIL:bool=true;
+		// TODO: remove mesh negation
+		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
+			// on_exact
+			|is_intersecting,_simplex|{
+				is_intersecting
+			},
+			// on_escape
+			|_simplex|{
+				// intersection is guaranteed at this point
+				true
+			},
+			// fast_fail value
+			||false
+		)
+	}
+
+	#[test]
+	fn test_cube_points(){
+		let mesh=PhysicsMesh::unit_cube();
+		let mesh_view=mesh.complete_mesh_view();
+		for x in -2..=2{
+			for y in -2..=2{
+				for z in -2..=2{
+					let point=vec3::int(x,y,z)>>1;
+					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
+				}
+			}
+		}
+	}
+}

engine/physics/src/model.rs

@@ -90,6 +90,9 @@ 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 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]>;
@@ -100,17 +103,21 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
+	// I didn't write it down, but I assume the edges are directed
+	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
+	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//bottom, top
+	verts:[SubmeshVertId;2],//start, end
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
+	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -432,7 +439,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -447,6 +454,22 @@ 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()
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.data.verts[vert_id.get() as usize].0)
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
+	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
@@ -485,7 +508,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
-#[derive(Debug)]
+#[derive(Debug,Clone,Copy)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -503,18 +526,6 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
-		//this happens to be well-defined.  there are no virtual virtices
-		SubmeshVertId::new(
-			self.view.topology.verts.iter()
-			.enumerate()
-			.max_by_key(|&(_,&vert_id)|
-				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
-			)
-			//assume there is more than zero vertices.
-			.unwrap().0 as u32
-		)
-	}
 }
 impl MeshQuery for TransformedMesh<'_>{
 	type Face=SubmeshFaceId;
@@ -532,6 +543,21 @@ 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
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.view.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
+	}
 	#[inline]
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
@@ -558,11 +584,20 @@ impl MeshQuery for TransformedMesh<'_>{
 //(face,vertex)
 //(edge,edge)
 //(vertex,face)
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
-#[derive(Clone,Copy,Debug)]
+// TODO: remove this
+impl core::ops::Neg for MinkowskiVert{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		match self{
+			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -577,7 +612,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -598,7 +633,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Hash)]
 pub enum MinkowskiFace{
 	VertFace(SubmeshVertId,SubmeshFaceId),
 	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
@@ -614,23 +649,20 @@ pub struct MinkowskiMesh<'a>{
 	mesh1:TransformedMesh<'a>,
 }
 
-//infinity fev algorithm state transition
-#[derive(Debug)]
-enum Transition{
-	Done,//found closest vert, no edges are better
-	Vert(MinkowskiVert),//transition to vert
-}
-enum EV{
-	Vert(MinkowskiVert),
-	Edge(MinkowskiEdge),
-}
-
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
 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{
@@ -638,155 +670,27 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	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{
-		let mut best_transition=Transition::Done;
-		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//is boundary uncrossable by a crawl from infinity
-			let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
-			//select opposite vertex
-			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
-			//test if it's closer
-			let diff=point-self.vert(test_vert_id);
-			if edge_n.dot(infinity_dir).is_zero(){
-				let distance_squared=diff.dot(diff);
-				if distance_squared<*best_distance_squared{
-					best_transition=Transition::Vert(test_vert_id);
-					*best_distance_squared=distance_squared;
-				}
-			}
-		}
-		best_transition
-	}
-	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
-		let mut best_transition=EV::Vert(vert_id);
-		let diff=point-self.vert(vert_id);
-		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//is boundary uncrossable by a crawl from infinity
-			//check if time of collision is outside Time::MIN..Time::MAX
-			if edge_n.dot(infinity_dir).is_zero(){
-				let d=edge_n.dot(diff);
-				//test the edge
-				let edge_nn=edge_n.dot(edge_n);
-				if !d.is_negative()&&d<=edge_nn{
-					let distance_squared={
-						let c=diff.cross(edge_n);
-						//wrap for speed
-						(c.dot(c)/edge_nn).divide().wrap_2()
-					};
-					if distance_squared<=*best_distance_squared{
-						best_transition=EV::Edge(directed_edge_id.as_undirected());
-						*best_distance_squared=distance_squared;
-					}
-				}
-			}
-		}
-		best_transition
-	}
-	fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
-		let mut best_distance_squared={
-			let diff=point-self.vert(vert_id);
-			diff.dot(diff)
-		};
-		loop{
-			match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
-				Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
-				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
-			}
-		}
-	}
-	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh<'_>>{
-		//start on any vertex
-		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
-		//cross edge-face boundary if it's uncrossable
-		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
-			//if a vert is returned, it is the closest point to the infinity point
-			EV::Vert(vert_id)=>FEV::Vert(vert_id),
-			EV::Edge(edge_id)=>{
-				//cross to face if the boundary is not crossable and we are on the wrong side
-				let edge_n=self.edge_n(edge_id);
-				// point is multiplied by two because vert_sum sums two vertices.
-				let delta_pos=point*2-{
-					let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-					self.vert(v0)+self.vert(v1)
-				};
-				for (i,&face_id) in self.edge_faces(edge_id).as_ref().iter().enumerate(){
-					let face_n=self.face_nd(face_id).0;
-					//edge-face boundary nd, n facing out of the face towards the edge
-					let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
-					let boundary_d=boundary_n.dot(delta_pos);
-					//check if time of collision is outside Time::MIN..Time::MAX
-					//infinity_dir can always be treated as a velocity
-					if !boundary_d.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
-						//both faces cannot pass this condition, return early if one does.
-						return FEV::Face(face_id);
-					}
-				}
-				FEV::Edge(edge_id)
-			},
-		}
-	}
-	// TODO: fundamentally improve this algorithm.
-	// All it needs to do is find the closest point on the mesh
-	// and return the FEV which the point resides on.
-	//
-	// What it actually does is use the above functions to trace a ray in from infinity,
-	// crawling the closest point along the mesh surface until the ray reaches
-	// the starting point to discover the final FEV.
-	//
-	// The actual collision prediction probably does a single test
-	// and then immediately returns with 0 FEV transitions on average,
-	// because of the strict time_limit constraint.
-	//
-	// Most of the calculation time is just calculating the starting point
-	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh<'_>>>{
-		infinity_body.infinity_dir().and_then(|dir|{
-			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;
-			//crawl in from negative infinity along a tangent line to get the closest fev
-			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)>{
-		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
-			//continue forwards along the body parabola
+		//continue forwards along the body parabola
-			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		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;
-		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
+		//continue backwards along the body parabola
-			//continue backwards along the body parabola
+		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			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
-				//no need to test -time<time_limit because of the first step
+			.map(|(face,time)|(face,-time))
-				.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
@@ -816,20 +720,8 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge
 	}
-	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
+		crate::minimum_difference::contains_point(self,point)
-		// 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<'_>{
@@ -868,6 +760,12 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
+	fn hint_point(&self)->Planar64Vec3{
+		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
 	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{

engine/physics/src/physics.rs

@@ -28,7 +28,6 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
-	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -114,11 +113,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
@@ -141,7 +140,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,
 		}
@@ -444,7 +443,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){
@@ -483,7 +482,7 @@ impl StyleHelper for StyleModifiers{
 		};
 		let transform=integer::Planar64Affine3::new(
 			mat3::from_diagonal(self.hitbox.halfsize),
-			vec3::ZERO
+			vec3::zero()
 		);
 		HitboxMesh::new(mesh,transform)
 	}
@@ -501,7 +500,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);
@@ -615,7 +614,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.contacts.contains_key(&walk_state.contact.convex_mesh_id){
+				Some(walk_state)=>if !touching.contains_contact(&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
@@ -730,7 +729,7 @@ struct IntersectModel{
 	transform:PhysicsMeshTransform,
 }
 
-#[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
+#[derive(Debug,Clone,Copy,Hash)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
@@ -739,7 +738,7 @@ pub struct ContactCollision{
 pub struct IntersectCollision{
 	convex_mesh_id:ConvexMeshId<IntersectModelId>,
 }
-#[derive(Debug,Clone,Eq,Hash,PartialEq)]
+#[derive(Debug,Clone,Hash)]
 pub enum Collision{
 	Contact(ContactCollision),
 	Intersect(IntersectCollision),
@@ -754,6 +753,8 @@ 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>>,
 }
@@ -774,10 +775,16 @@ 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.contacts.contains_key(&convex_mesh_id.map(contact_model_id)),
+			PhysicsModelId::Contact(contact_model_id)=>self.contains_contact(&convex_mesh_id.map(contact_model_id)),
-			PhysicsModelId::Intersect(intersect_model_id)=>self.intersects.contains(&convex_mesh_id.map(intersect_model_id)),
+			PhysicsModelId::Intersect(intersect_model_id)=>self.contains_intersect(&convex_mesh_id.map(intersect_model_id)),
 		}
 	}
 	fn base_acceleration(&self,models:&PhysicsModels,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->Planar64Vec3{
@@ -803,7 +810,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,
 			}
@@ -814,7 +821,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,
 			}
@@ -828,7 +835,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(
@@ -842,7 +849,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(
@@ -1189,7 +1196,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);
@@ -1207,7 +1214,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(),
@@ -1270,7 +1277,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.is_point_in_mesh(body.position){
+		if minkowski.contains_point(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
@@ -1565,7 +1572,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);
@@ -1736,14 +1743,17 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	match ins.instruction{
+	let (should_advance_body,goober_time)=match ins.instruction{
-		// collisions advance the body precisely
 		InternalInstruction::CollisionStart(_,dt)
-		|InternalInstruction::CollisionEnd(_,dt)=>state.body.advance_time_ratio_dt(dt),
+		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
-		// this advances imprecisely
+		InternalInstruction::StrafeTick
-		InternalInstruction::ReachWalkTargetVelocity=>state.body.advance_time(state.time),
+		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
-		// strafe tick decides for itself whether to advance the body.
+	};
-		InternalInstruction::StrafeTick=>(),
+	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,_)=>{
@@ -1789,9 +1799,7 @@ 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
@@ -1814,7 +1822,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!
@@ -1896,7 +1904,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
@@ -1909,7 +1917,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;
 		}
@@ -1959,7 +1967,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();
@@ -1975,7 +1983,7 @@ mod test{
 					int3(0,1,0)>>1,
 					int3(-1,0,5)>>1,
 				]),
-				vec3::ZERO
+				vec3::zero()
 			),
 		);
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
@@ -1994,7 +2002,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)));
 	}
@@ -2003,7 +2011,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)));
 	}
@@ -2012,7 +2020,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)));
 	}
@@ -2021,7 +2029,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)));
 	}
@@ -2030,7 +2038,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)));
 	}
@@ -2039,7 +2047,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)));
 	}
@@ -2156,7 +2164,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)));
 	}
@@ -2172,7 +2180,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
@@ -2184,7 +2192,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)))
 	}
@@ -2193,7 +2201,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)))
 	}
@@ -2202,7 +2210,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)))
 	}
@@ -2211,7 +2219,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)))
 	}
@@ -2221,7 +2229,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)
 	}
@@ -2230,7 +2238,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)
 	}
@@ -2239,7 +2247,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)
 	}
@@ -2248,7 +2256,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)
 	}
@@ -2258,7 +2266,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)
 	}
@@ -2267,7 +2275,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)
 	}
@@ -2276,7 +2284,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)
 	}
@@ -2285,7 +2293,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,20 +39,18 @@ 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()<EPSILON{
+	if det.abs()==Fixed::ZERO{
 		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()<EPSILON{
+	if det.abs()==Fixed::ZERO{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
@@ -60,10 +58,9 @@ 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()<EPSILON{
+	if det.abs()==Fixed::ZERO{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
@@ -149,7 +146,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
@@ -321,13 +318,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,14 +101,12 @@ 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));
-	// EXPECTED: touch top of part at 5,-5,0
+	// 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_2{
+			if cr==crate::integer::vec3::zero(){
-				crate::integer::vec3::ZERO
+				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_2{
+			if cr==crate::integer::vec3::zero(){
-				crate::integer::vec3::ZERO
+				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,12 +561,6 @@ 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]);
@@ -575,6 +569,10 @@ 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)])
@@ -663,7 +661,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,6 +70,34 @@ 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
@@ -338,7 +366,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 
 // This macro is not used in the default configuration.
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -517,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

lib/rbx_loader/Cargo.toml

@@ -13,16 +13,16 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 bytemuck = "1.14.3"
 glam = "0.30.0"
 regex = { version = "1.11.3", default-features = false }
-rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
 rbx_mesh = "0.5.0"
-rbx_reflection = "5.0.0"
-rbx_reflection_database = "1.0.0"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
+rbx_binary = "2.0.1"
+rbx_dom_weak = "4.1.0"
+rbx_reflection = "6.1.0"
+rbx_reflection_database = "2.0.2"
+rbx_xml = "2.0.1"
 
 [lints]
 workspace = true

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{
@@ -559,7 +559,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|

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})

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,10 @@ run-service=[]
 glam = "0.30.0"
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
-rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = "4.1.0"
-rbx_reflection = "5.0.0"
+rbx_reflection = "6.1.0"
-rbx_reflection_database = "1.0.0"
+rbx_reflection_database = "2.0.2"
-rbx_types = "2.0.0"
+rbx_types = "3.1.0"
 
 [lints]
 workspace = true

lib/roblox_emulator/src/context.rs

@@ -52,7 +52,7 @@ impl Context{
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get();
+		let db=rbx_reflection_database::get().unwrap();
 		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};

lib/roblox_emulator/src/runner/enum.rs

@@ -37,7 +37,7 @@ impl PartialEq for EnumItem<'_>{
 pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get();
+		let db=rbx_reflection_database::get().unwrap();
 		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }

lib/roblox_emulator/src/runner/instance/instance.rs

@@ -37,7 +37,7 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>
 }
 
 pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
@@ -80,14 +80,14 @@ pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak
 }
 
 pub fn find_first_child_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
 pub fn find_first_descendant_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
@@ -282,7 +282,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
-				let db=rbx_reflection_database::get();
+				let db=rbx_reflection_database::get().unwrap();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
@@ -344,7 +344,7 @@ impl mlua::UserData for Instance{
 			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
-				let db=rbx_reflection_database::get();
+				let db=rbx_reflection_database::get().unwrap();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)

map-tool/Cargo.toml

@@ -13,10 +13,10 @@ futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
-rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_binary = "2.0.1"
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = "4.1.0"
-rbx_reflection_database = "1.0.0"
+rbx_reflection_database = "2.0.2"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_xml = "2.0.1"
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }

strafe-client/Cargo.toml

@@ -28,7 +28,7 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "27.0.0"
+wgpu = "28.0.0"
 winit = "0.30.7"
 
 [profile.dev]

strafe-client/src/setup.rs

@@ -52,7 +52,7 @@ impl<'a> SetupContextPartial2<'a>{
 		let required_features=required_features();
 
 		//no helper function smh gotta write it myself
-		let adapters=self.instance.enumerate_adapters(self.backends);
+		let adapters=pollster::block_on(self.instance.enumerate_adapters(self.backends));
 
 		let mut chosen_adapter=None;
 		let mut chosen_adapter_score=0;