negative everything

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 = "28.0.0"
+wgpu = "27.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::MipmapFilterMode::Linear,
+			mipmap_filter:wgpu::FilterMode::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::MipmapFilterMode::Linear,
+			mipmap_filter:wgpu::FilterMode::Linear,
 			anisotropy_clamp:16,
 			..Default::default()
 		});
@@ -754,7 +754,7 @@ impl GraphicsState{
 				&skybox_texture_bind_group_layout,
 				&model_bind_group_layout,
 			],
-			immediate_size:0,
+			push_constant_ranges:&[],
 		});
 		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,
 			],
-			immediate_size:0,
+			push_constant_ranges:&[],
 		});
 
 		// Create the render pipelines
@@ -793,7 +793,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
+			multiview: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_mask:None,
+			multiview:None,
 			cache:None,
 		});
 
@@ -880,7 +880,7 @@ impl GraphicsState{
 			camera_buf,
 			models:Vec::new(),
 			depth_view,
-			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
+			staging_belt:wgpu::util::StagingBelt::new(0x100),
 			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
@@ -918,6 +918,7 @@ 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
@@ -964,7 +965,6 @@ 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/face_crawler.rs

@@ -21,6 +21,12 @@ 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/minimum_difference.rs

@@ -1,23 +1,20 @@
 use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
+use strafesnet_common::integer::{Fixed,Planar64Vec3};
 
-use crate::model::{DirectedEdge,FEV,MeshQuery};
-// TODO: remove mesh invert
-use crate::model::{MinkowskiMesh,MinkowskiVert};
+use crate::model::{MeshQuery,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,Debug)]
-enum Simplex1_3<Vert>{
-	Simplex1(Simplex<1,Vert>),
-	Simplex2(Simplex<2,Vert>),
-	Simplex3(Simplex<3,Vert>),
+type Simplex<const N:usize>=[MinkowskiVert;N];
+enum Simplex1_3{
+	Simplex1(Simplex<1>),
+	Simplex2(Simplex<2>),
+	Simplex3(Simplex<3>),
 }
-impl<Vert> Simplex1_3<Vert>{
-	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
+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]),
@@ -25,11 +22,10 @@ impl<Vert> Simplex1_3<Vert>{
 		}
 	}
 }
-#[derive(Clone,Copy)]
-enum Simplex2_4<Vert>{
-	Simplex2(Simplex<2,Vert>),
-	Simplex3(Simplex<3,Vert>),
-	Simplex4(Simplex<4,Vert>),
+enum Simplex2_4{
+	Simplex2(Simplex<2>),
+	Simplex3(Simplex<3>),
+	Simplex4(Simplex<4>),
 }
 
 /*
@@ -45,23 +41,23 @@ local function absDet(r, u, v, w)
 	end
 end
 */
-impl<Vert> Simplex2_4<Vert>{
-	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
+impl Simplex2_4{
+	fn det_is_zero(&self,mesh:&MinkowskiMesh)->bool{
 		match self{
-			Self::Simplex4([p0,p1,p2,p3])=>{
+			&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])=>{
+			&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])=>{
+			&Self::Simplex2([p0,p1])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				p1-p0==vec3::zero()
@@ -100,51 +96,17 @@ 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,
+fn reduce1(
+	[v0]:Simplex<1>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
-	println!("reduce1");
+)->Reduced{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
-	let p0=mesh.vert(v0);
+	let p0=-mesh.vert(v0);
 
-	println!("p0={p0}");
 	// local p = -a
 	let p=-(p0+point);
-	println!("p={p}");
 
 	// local direction = p
 	let mut dir=p;
@@ -163,17 +125,16 @@ fn reduce1<M:MeshQuery>(
 }
 
 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery>(
-	[v0,v1]:Simplex<2,M::Vert>,
-	mesh:&M,
+fn reduce2(
+	[v0,v1]:Simplex<2>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
-	println!("reduce2");
+)->Reduced{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
+	let p0=-mesh.vert(v0);
+	let p1=-mesh.vert(v1);
 
 	// local p = -a
 	// local u = b - a
@@ -200,7 +161,7 @@ fn reduce2<M:MeshQuery>(
 		// -- modify the direction to take into account a0R and b0R
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -221,19 +182,18 @@ fn reduce2<M:MeshQuery>(
 }
 
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery>(
-	[v0,mut v1,v2]:Simplex<3,M::Vert>,
-	mesh:&M,
+fn reduce3(
+	[v0,mut v1,v2]:Simplex<3>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
-	println!("reduce3");
+)->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);
+	let p0=-mesh.vert(v0);
+	let p1=-mesh.vert(v1);
+	let p2=-mesh.vert(v2);
 
 	// local p = -a
 	// local u = b - a
@@ -267,7 +227,7 @@ fn reduce3<M:MeshQuery>(
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
-			dir:narrow_dir2(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 		};
 	}
@@ -301,14 +261,14 @@ fn reduce3<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uv
 			return Reduced{
-				dir:narrow_dir2(uv),
+				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}
 
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -319,7 +279,7 @@ fn reduce3<M:MeshQuery>(
 	if dir==vec3::zero(){
 		// direction = uv
 		return Reduced{
-			dir:narrow_dir2(uv),
+			dir:uv.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex1([v0]),
 		};
 	}
@@ -331,21 +291,20 @@ fn reduce3<M:MeshQuery>(
 }
 
 // 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,
+fn reduce4(
+	[v0,mut v1,mut v2,v3]:Simplex<4>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduce<M::Vert>{
-	println!("reduce4");
+)->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);
+	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
@@ -355,10 +314,6 @@ fn reduce4<M:MeshQuery>(
 	let mut u=p1-p0;
 	let mut v=p2-p0;
 	let w=p3-p0;
-	println!("p={p}");
-	println!("u={u}");
-	println!("v={v}");
-	println!("w={w}");
 
 	// local uv = u:Cross(v)
 	// local vw = v:Cross(w)
@@ -377,8 +332,8 @@ fn reduce4<M:MeshQuery>(
 
 	// 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(){
+	 ||!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
@@ -406,6 +361,8 @@ fn reduce4<M:MeshQuery>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
+		}else{
+			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -418,6 +375,8 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}
 
@@ -429,25 +388,19 @@ fn reduce4<M:MeshQuery>(
 	let pv=p.cross(v);
 	let uv_up=uv.dot(up);
 	let uv_pv=uv.dot(pv);
-	println!("up={up}");
-	println!("pv={pv}");
-	println!("uv_up={uv_up}");
-	println!("uv_pv={uv_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(){
-			println!("a");
 			return Reduce::Reduced(Reduced{
-				dir:narrow_dir2(uv),
+				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}else{
-			println!("b");
 			return Reduce::Reduced(Reduced{
-				dir:narrow_dir2(-uv),
+				dir:-uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}
@@ -483,24 +436,21 @@ fn reduce4<M:MeshQuery>(
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
 			if uv_w.is_negative(){
-				println!("c");
 				return Reduce::Reduced(Reduced{
-					dir:narrow_dir2(uv),
+					dir:uv.narrow_1().unwrap(),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}else{
-				println!("d");
 				return Reduce::Reduced(Reduced{
-					dir:narrow_dir2(-uv),
+					dir:-uv.narrow_1().unwrap(),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}
 		}
 
-		println!("e");
 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		});
 	}
@@ -511,21 +461,18 @@ fn reduce4<M:MeshQuery>(
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
 		if uv_w.is_negative(){
-			println!("f");
 			return Reduce::Reduced(Reduced{
-				dir:narrow_dir2(uv),
+				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}else{
-			println!("g");
 			return Reduce::Reduced(Reduced{
-				dir:narrow_dir2(-uv),
+				dir:-uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}
 	}
 
-	println!("h");
 	// return direction, a0, a1
 	Reduce::Reduced(Reduced{
 		dir,
@@ -533,18 +480,18 @@ fn reduce4<M:MeshQuery>(
 	})
 }
 
-struct Reduced<Vert>{
+struct Reduced{
 	dir:Planar64Vec3,
-	simplex:Simplex1_3<Vert>,
+	simplex:Simplex1_3,
 }
 
-enum Reduce<Vert>{
-	Escape(Simplex<4,Vert>),
-	Reduced(Reduced<Vert>),
+enum Reduce{
+	Escape(Simplex<4>),
+	Reduced(Reduced),
 }
 
-impl<Vert> Simplex2_4<Vert>{
-	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
+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)),
@@ -553,265 +500,57 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
-//infinity fev algorithm state transition
-#[derive(Debug)]
-enum Transition<Vert>{
-	Done,//found closest vert, no edges are better
-	Vert(Vert),//transition to vert
+// 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!()
 }
-enum EV<M:MeshQuery>{
-	Vert(M::Vert),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+
+/// 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<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),
-		}
+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!()
 	}
 }
-
-trait Contains{
-	fn contains(&self,point:Planar64Vec3)->bool;
+pub struct Details{
+	// distance:Planar64,
+	// p_pos:Planar64Vec3,
+	// p_norm:Planar64Vec3,
+	// q_pos:Planar64Vec3,
+	// q_norm:Planar64Vec3,
 }
 
-// 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)
-		},
-	}
-}
-
-#[derive(Debug)]
-pub struct InfiniteLoop;
-pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Result<Option<FEV<MinkowskiMesh<'a>>>,InfiniteLoop>{
-	println!("=== LUA ===");
-	let (hits,_details)=crate::minimum_difference_lua::minimum_difference_details(mesh,point).unwrap();
-	println!("=== RUST ===");
-	let closest_fev_not_inside=closest_fev_not_inside_inner(mesh,point).unwrap();
-	assert_eq!(hits,closest_fev_not_inside.is_none(),"algorithms disagree");
-	Ok(closest_fev_not_inside)
-}
-
-pub fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Result<Option<FEV<MinkowskiMesh<'a>>>,InfiniteLoop>{
-	const ENABLE_FAST_FAIL:bool=false;
-	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
-		// on_exact
-		|is_intersecting,simplex|{
-			println!("on_exact simplex={simplex:?}");
-			if is_intersecting{
-				return Ok(None);
-			}
-			// Convert simplex to FEV
-			// Vertices must be inverted since the mesh is inverted
-			Ok(Some(match simplex{
-				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
-				Simplex1_3::Simplex2([v0,v1])=>{
-					// invert
-					let (v0,v1)=(-v0,-v1);
-					crawl_to_closest_ev(mesh,[v0,v1],point).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
-					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
-				},
-			}))
-		},
-		// 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);
-			Ok(None)
-		},
-		// fast_fail value is irrelevant and will never be returned!
-		||unreachable!(),
-		||Err(InfiniteLoop),
-	)
-}
-
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+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,
+	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
 		// on_exact
-		|is_intersecting,_simplex|{
-			is_intersecting
+		|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|{
@@ -819,9 +558,22 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 			true
 		},
 		// fast_fail value
-		||false,
-		// infinite loop
-		||false,
+		||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!()
 	)
 }
 
@@ -830,46 +582,38 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
-	mesh:&M,
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
-	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
+	on_exact:impl FnOnce(Planar64Vec3,Planar64Vec3)->T,
+	on_escape:impl FnOnce(Simplex<4>)->T,
 	on_fast_fail:impl FnOnce()->T,
-	on_infinite_loop: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;
+	let mut initial_axis=-mesh.hint_point()+point;
 	// degenerate case
 	if initial_axis==vec3::zero(){
 		initial_axis=choose_any_direction();
 	}
-	println!("initial_axis={initial_axis}");
-	let last_point=mesh.farthest_vert(-initial_axis);
+	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 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
-	for _ in 0..100{
-		println!("direction={direction}");
-
+	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);
+		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
-		let d=direction.dot(next_pos+point);
-		let fast_fail=d.is_negative();
-		println!("ENABLE_FAST_FAIL={ENABLE_FAST_FAIL} fast_fail={fast_fail} next_point={} dot={d}",next_pos+point);
-		if ENABLE_FAST_FAIL&&fast_fail{
-			println!("on_fast_fail");
+		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
 			return on_fast_fail();
 		}
 
@@ -878,24 +622,16 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		// if
 		// 	direction:Dot(next_point - a) <= 0 or
 		// 	absDet(next_point, a, b, c) < 1e-6
-		let cond1=!direction.dot(next_pos-last_pos).is_positive();
-		let cond2=simplex_big.det_is_zero(mesh);
-		println!("cond1={cond1} cond2={cond2}");
-		if cond1||cond2{
-			println!("on_exact");
+		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);
+			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)=>{
-				println!("on_escape");
 				// Enough information to conclude that the meshes are intersecting.
 				// Topology information is computed if needed.
 				return on_escape(simplex);
@@ -909,44 +645,4 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		// next loop this will be a
 		last_pos=next_pos;
 	}
-	on_infinite_loop()
-}
-
-#[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,
-			||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/minimum_difference_lua.rs

@@ -12,9 +12,9 @@ pub fn contains_point(
 pub fn minimum_difference_details(
 	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->LuaResult<(bool,Option<Details>)>{
+)->LuaResult<(bool,Details)>{
 	let md=minimum_difference(mesh,point,false)?;
-	Ok((md.hits,md.details))
+	Ok((md.hits,md.details.unwrap()))
 }
 fn p64v3(v:Vector)->Result<Planar64Vec3,FixedFromFloatError>{
 	Ok(Planar64Vec3::new([
@@ -65,23 +65,6 @@ impl FromLuaMulti for MinimumDifference{
 					q_norm:p64v3(q_norm).unwrap(),
 				}),
 			}),
-			&mut [
-				mlua::Value::Boolean(hits),
-				mlua::Value::Integer(distance),
-				mlua::Value::Vector(p_pos),
-				mlua::Value::Vector(p_norm),
-				mlua::Value::Vector(q_pos),
-				mlua::Value::Vector(q_norm),
-			]=>Ok(Self{
-				hits,
-				details:Some(Details{
-					distance:distance.into(),
-					p_pos:p64v3(p_pos).unwrap(),
-					p_norm:p64v3(p_norm).unwrap(),
-					q_pos:p64v3(q_pos).unwrap(),
-					q_norm:p64v3(q_norm).unwrap(),
-				}),
-			}),
 			values=>Err(mlua::Error::runtime(format!("Invalid return values: {values:?}"))),
 		}
 	}
@@ -92,6 +75,7 @@ struct Args{
 	radius_p:f64,
 	query_q:Function,
 	radius_q:f64,
+	exit_radius:f64,
 	test_intersection:bool,
 }
 impl Args{
@@ -103,6 +87,7 @@ impl Args{
 	)->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{
@@ -128,6 +113,7 @@ impl Args{
 			radius_p,
 			query_q,
 			radius_q,
+			exit_radius,
 			test_intersection,
 		})
 	}
@@ -140,7 +126,7 @@ impl IntoLuaMulti for Args{
 			self.radius_p.into_lua(lua)?,
 			self.query_q.into_lua(lua)?,
 			self.radius_q.into_lua(lua)?,
-			mlua::Value::Nil,
+			self.exit_radius.into_lua(lua)?,
 			self.test_intersection.into_lua(lua)?,
 		]))
 	}
@@ -163,7 +149,7 @@ struct Ctx{
 	f:Function,
 }
 fn init_lua()->LuaResult<Ctx>{
-	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("Trey-MinimumDifference.lua").unwrap());
+	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()?;

engine/physics/src/model.rs

@@ -92,7 +92,6 @@ pub trait MeshQuery{
 	}
 	/// 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]>;
@@ -103,21 +102,17 @@ 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],//start, end
+	verts:[SubmeshVertId;2],//bottom, top
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
-	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -439,7 +434,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -458,18 +453,6 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		// 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;
@@ -508,7 +491,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -526,6 +509,18 @@ 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{
+		//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;
@@ -546,18 +541,6 @@ impl MeshQuery for TransformedMesh<'_>{
 	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)
@@ -588,16 +571,7 @@ impl MeshQuery for TransformedMesh<'_>{
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
-// TODO: remove this
-impl core::ops::Neg for MinkowskiVert{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		match self{
-			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -633,7 +607,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash)]
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 pub enum MinkowskiFace{
 	VertFace(SubmeshVertId,SubmeshFaceId),
 	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
@@ -649,20 +623,23 @@ pub struct MinkowskiMesh<'a>{
 	pub 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{
@@ -670,31 +647,140 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Result<Option<(MinkowskiFace,GigaTime)>,crate::minimum_difference::InfiniteLoop>{
-		let Some(fev)=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?else{
-			return Ok(None);
-		};
-		//continue forwards along the body parabola
-		Ok(fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit())
+	pub fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Result<Option<(MinkowskiFace,GigaTime)>,crate::minimum_difference::InfiniteLoop>{
+	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
+			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
+		})
+	}
+	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|{
+			//continue forwards along the body parabola
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		})
+	}
+	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// TODO: handle unbounded collision using infinity fev
-		let time=match upper_bound{
-			Bound::Included(&time)=>time,
-			Bound::Excluded(&time)=>time,
-			Bound::Unbounded=>unimplemented!("unbounded collision out"),
-		};
-		let Some(fev)=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?else{
-			return Ok(None);
-		};
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
 		let infinity_body=-relative_body;
-		//continue backwards along the body parabola
-		Ok(fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time)))
+		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
+			//continue backwards along the body parabola
+			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+				//no need to test -time<time_limit because of the first step
+				.map(|(face,time)|(face,-time))
+		})
 	}
 	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		// TODO: make better
@@ -725,7 +811,10 @@ impl MinkowskiMesh<'_>{
 		best_edge
 	}
 	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		crate::minimum_difference::contains_point(self,point)
+		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
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -767,9 +856,6 @@ 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

@@ -729,7 +729,7 @@ struct IntersectModel{
 	transform:PhysicsMeshTransform,
 }
 
-#[derive(Debug,Clone,Copy,Hash)]
+#[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
@@ -738,7 +738,7 @@ pub struct ContactCollision{
 pub struct IntersectCollision{
 	convex_mesh_id:ConvexMeshId<IntersectModelId>,
 }
-#[derive(Debug,Clone,Hash)]
+#[derive(Debug,Clone,Eq,Hash,PartialEq)]
 pub enum Collision{
 	Contact(ContactCollision),
 	Intersect(IntersectCollision),
@@ -828,7 +828,7 @@ impl TouchingState{
 		}).collect();
 		crate::push_solve::push_solve(&contacts,acceleration)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time)->Result<(),crate::minimum_difference::InfiniteLoop>{
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
 		for (convex_mesh_id,face_id) in &self.contacts{
@@ -849,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(
@@ -859,7 +859,6 @@ impl TouchingState{
 				}
 			}));
 		}
-		Ok(())
 	}
 }
 
@@ -1200,7 +1199,7 @@ impl<'a> PhysicsContext<'a>{
 		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).unwrap();
+		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
 		//check for collision starts
 		let mut aabb=aabb::Aabb::default();
 		state.body.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1215,17 +1214,17 @@ 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());
-			let Ok(collision)=minkowski.predict_collision_in(relative_body,state.time..collector.time())else{
-				println!("Infinite loop! body={relative_body}");
-				return;
-			};
-			collector.collect(collision.map(|(face,dt)|TimedInstruction{
-				time:relative_body.time+dt.into(),
-				instruction:InternalInstruction::CollisionStart(
-					Collision::new(*convex_mesh_id,face),
-					dt
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
+				.map(|(face,dt)|
+					TimedInstruction{
+						time:relative_body.time+dt.into(),
+						instruction:InternalInstruction::CollisionStart(
+							Collision::new(*convex_mesh_id,face),
+							dt
+						)
+					}
 				)
-			}));
+			);
 		});
 		collector.take()
 	}
@@ -1973,7 +1972,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10)).unwrap();
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -1991,7 +1990,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10)).unwrap();
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){

integration-testing/src/test_scenes.rs

@@ -115,40 +115,3 @@ fn bug_3(){
 	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }
-
-fn test_scene_cylinder()->PhysicsData{
-	let mut builder=TestSceneBuilder::new();
-	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
-	let mesh=builder.push_mesh(strafesnet_rbx_loader::primitives::unit_cylinder(cube_face_description));
-	// place one 5x5x5 cylinder.
-	builder.push_mesh_instance(mesh,Planar64Affine3::new(
-		mat3::from_diagonal(vec3::int(5,5,5)>>1),
-		vec3::int(0,-5,0)
-	));
-	builder.build()
-}
-
-#[test]
-fn test_minimum_difference(){
-	let physics_data=test_scene_cylinder();
-	let body=strafesnet_physics::physics::Body::new(
-		vec3::int(4,1,4)>>1,
-		vec3::int(-1,-1,-2),
-		vec3::int(0,-100,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	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
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
-	assert!(phys_iter.next().is_none());
-	let body=physics.body();
-	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
-	assert_eq!(body.velocity,vec3::int(0,0,0));
-	assert_eq!(body.acceleration,vec3::int(0,0,0));
-	assert_eq!(body.time,Time::from_secs(2));
-}

integration-testing/src/tests.rs

@@ -74,39 +74,3 @@ fn physics_bug_3()->Result<(),ReplayError>{
 
 	Ok(())
 }
-
-// Infinite loop! body=p(-1796.657, 677.618, 36.959) v(3.158, -53.650, -34.435) a(-0.000, -71.276, -45.248) t(288s+440000000ns)
-// Infinite loop! body=p(-2382.440, 160.150, -379.151) v(53.632, 35.779, 44.904) a(0.000, -100.000, 0.000) t(306s+675758543ns)
-// Infinite loop! body=p(-1798.724, 731.459, 68.784) v(-17.389, 0.000, -78.087) a(0.000, 0.000, 0.000) t(284s+006980061ns)
-// Infinite loop! body=p(-1796.657, 677.618, 36.959) v(3.158, -53.650, -34.435) a(-0.000, -71.276, -45.248) t(288s+440000000ns)
-// Infinite loop! body=p(-1797.504, 738.529, 74.864) v(-3.653, 0.000, -79.917) a(0.000, 0.000, 0.000) t(282s+709871336ns)
-// Infinite loop! body=p(-1797.569, 735.449, 71.859) v(23.726, -76.309, -3.747) a(0.000, 0.000, 0.000) t(283s+325193187ns)
-
-#[test]
-fn physics_md_infinite_loop()->Result<(),ReplayError>{
-	println!("loading map file..");
-	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
-	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
-
-	// create recording
-	println!("generating models..");
-	let physics_data=PhysicsData::new(&map);
-	println!("simulating...");
-
-	//teleport to bug
-	use strafesnet_common::integer::{vec3,Time};
-	let body=strafesnet_physics::physics::Body::new(
-		vec3::try_from_f32_array([-1796.657, 677.618, 36.959]).unwrap(),
-		vec3::try_from_f32_array([3.158, -53.650, -34.435]).unwrap(),
-		vec3::int(0,-100,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	// wait one second to activate the bug
-	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
-		time:Time::from_millis(500),
-		instruction:strafesnet_common::physics::Instruction::Idle,
-	});
-
-	Ok(())
-}

lib/fixed_wide/src/fixed.rs

@@ -366,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.
-#[expect(unused_macros)]
+#[allow(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>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

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

@@ -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().unwrap();
+	let db=rbx_reflection_database::get();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.2"
+version = "0.5.1"
 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 = "4.1.0"
-rbx_reflection = "6.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_types = "3.1.0"
+rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_types = "2.0.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().unwrap();
+		let db=rbx_reflection_database::get();
 		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().unwrap();
+		let db=rbx_reflection_database::get();
 		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().unwrap();
+	let db=rbx_reflection_database::get();
 	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().unwrap();
+	let db=rbx_reflection_database::get();
 	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().unwrap();
+	let db=rbx_reflection_database::get();
 	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().unwrap();
+				let db=rbx_reflection_database::get();
 				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().unwrap();
+				let db=rbx_reflection_database::get();
 				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 = "2.0.1"
-rbx_dom_weak = "4.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_xml = "2.0.1"
+rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 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 = "28.0.0"
+wgpu = "27.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=pollster::block_on(self.instance.enumerate_adapters(self.backends));
+		let adapters=self.instance.enumerate_adapters(self.backends);
 
 		let mut chosen_adapter=None;
 		let mut chosen_adapter_score=0;