fix bug 3, break everything else

.gitignore

@@ -1,2 +1 @@
 /target
-.zed

Cargo.toml

@@ -24,14 +24,3 @@ resolver = "2"
 #lto = true
 strip = true
 codegen-units = 1
-
-[workspace.lints.rust]
-# unsafe_code = "forbid"
-# missing_docs = "warn"
-# missing_debug_implementations = "warn"
-single_use_lifetimes = "warn"
-trivial_casts = "warn"
-unused_lifetimes = "warn"
-unused_qualifications = "warn"
-# variant_size_differences = "warn"
-unexpected_cfgs = "warn"

engine/graphics/Cargo.toml

@@ -11,7 +11,4 @@ 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 = "26.0.1"
-
-[lints]
-workspace = true

engine/graphics/src/graphics.rs

@@ -94,7 +94,7 @@ impl GraphicsCamera{
 		raw
 	}
 }
-impl Default for GraphicsCamera{
+impl std::default::Default for GraphicsCamera{
 	fn default()->Self{
 		Self{
 			screen_size:glam::UVec2::ONE,
@@ -167,7 +167,7 @@ impl GraphicsState{
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
 		//generate texture view per texture
-		let texture_views:HashMap<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
+		let texture_views:HashMap<strafesnet_common::model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
 			let image=match ddsfile::Dds::read(std::io::Cursor::new(texture_data)){
 				Ok(image)=>image,
@@ -803,7 +803,7 @@ impl GraphicsState{
 				module:&shader,
 				entry_point:Some("vs_entity_texture"),
 				buffers:&[wgpu::VertexBufferLayout{
-					array_stride:size_of::<GraphicsVertex>() as wgpu::BufferAddress,
+					array_stride:std::mem::size_of::<GraphicsVertex>() as wgpu::BufferAddress,
 					step_mode:wgpu::VertexStepMode::Vertex,
 					attributes:&wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x3,3=>Float32x4],
 				}],

engine/physics/Cargo.toml

@@ -8,6 +8,3 @@ arrayvec = "0.7.6"
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-
-[lints]
-workspace = true

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,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/lib.rs

@@ -1,8 +1,7 @@
 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

@@ -1,875 +0,0 @@
-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 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:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		};
-	}
-
-	// local direction = p
-	let mut dir=p;
-
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		dir=choose_perpendicular_direction(u);
-	}
-
-	// return direction, a0, a1
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<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:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		};
-	}
-
-	// local u_u = u:Dot(u)
-	// local v_v = v:Dot(v)
-	// local uDist = uv_up/(u_u*v.magnitude)
-	// local vDist = uv_pv/(v_v*u.magnitude)
-	// local minDist2 = math.min(uDist, vDist)
-	let u_dist=uv_up*v.length();
-	let v_dist=uv_pv*u.length();
-
-	// if vDist == minDist2 then
-	if v_dist<u_dist{
-		u=v;
-		up=-pv;
-		uv=-uv;
-		// b0 = c0
-		// b1 = c1
-		v1=v2;
-	}
-
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = up:Cross(u)
-		let direction=up.cross(u);
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			// direction = uv
-			return Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			};
-		}
-
-		// return direction, a0, a1, b0, b1
-		return Reduced{
-			dir:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		};
-	}
-
-	// local direction = p
-	let dir=p;
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		// direction = uv
-		return Reduced{
-			dir:uv.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex1([v0]),
-		};
-	}
-	// return direction, a0, a0
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<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:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
-		}else{
-			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
-		}
-	}
-
-	// local u_u = u:Dot(u)
-	// local v_v = v:Dot(v)
-	// local uDist = uv_up/(u_u*v.magnitude)
-	// local vDist = uv_pv/(v_v*u.magnitude)
-	// local minDist2 = math.min(uDist, vDist)
-	let u_dist=uv_up*v.length();
-	let v_dist=uv_pv*u.length();
-
-	// if vDist == minDist2 then
-	if v_dist<u_dist{
-		u=v;
-		up=-pv;
-		uv=-uv;
-		// b0 = c0
-		// b1 = c1
-		v1=v2;
-	}
-
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = up:Cross(u)
-		let direction=up.cross(u);
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			// direction = uvw < 0 and uv or -uv
-			// return direction, a0, a1, b0, b1
-			if uv_w.is_negative(){
-				return Reduce::Reduced(Reduced{
-					dir:uv.narrow_1().unwrap(),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
-			}else{
-				return Reduce::Reduced(Reduced{
-					dir:-uv.narrow_1().unwrap(),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
-			}
-		}
-
-		// return direction, a0, a1, b0, b1
-		return Reduce::Reduced(Reduced{
-			dir:direction.narrow_1().unwrap(),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		});
-	}
-
-	// local direction = p
-	let dir=p;
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		// direction = uvw < 0 and uv or -uv
-		if uv_w.is_negative(){
-			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
-		}else{
-			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
-		}
-	}
-
-	// return direction, a0, a1
-	Reduce::Reduced(Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	})
-}
-
-struct Reduced<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();
-		assert!(mesh_contains_point(mesh_view,vec3::NEG_Z));
-	}
-}

engine/physics/src/model.rs

@@ -90,9 +90,6 @@ pub trait MeshQuery{
 		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
 		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
 	}
-	/// This must return a point inside the mesh.
-	fn hint_point(&self)->Planar64Vec3;
-	fn 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]>;
@@ -435,7 +432,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -450,22 +447,6 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let face_idx=self.topology.faces[face_id.get() as usize].get() as usize;
 		(self.data.faces[face_idx].normal,self.data.faces[face_idx].dot)
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		// invariant: meshes always encompass the origin
-		vec3::zero()
-	}
-	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;
@@ -504,7 +485,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -519,9 +500,21 @@ impl TransformedMesh<'_>{
 			transform,
 		}
 	}
-	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
+	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::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;
@@ -539,21 +532,6 @@ impl MeshQuery for TransformedMesh<'_>{
 		// wrap for speed
 		self.transform.vertex.transform_point3(self.view.vert(vert_id)).wrap_1()
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.transform.vertex.translation
-	}
-	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)
@@ -580,20 +558,11 @@ impl MeshQuery for TransformedMesh<'_>{
 //(face,vertex)
 //(edge,edge)
 //(vertex,face)
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
-// TODO: remove this
+#[derive(Clone,Copy,Debug)]
-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),
@@ -608,7 +577,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -629,7 +598,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),
@@ -645,20 +614,23 @@ 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{
@@ -666,28 +638,150 @@ 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
+			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)>{
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
-		//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 fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
 		// 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
+		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
-		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			//continue backwards along the body parabola
-			//no need to test -time<time_limit because of the first step
+			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			.map(|(face,time)|(face,-time))
+				//no need to test -time<time_limit because of the first step
+				.map(|(face,time)|(face,-time))
+		})
 	}
 	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		// TODO: make better
 		use crate::face_crawler::{low,upp};
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
-		let start_time=range.start_bound().map(|&t|(t-relative_body.time).to_ratio());
+		let start_time=range.start_bound().map(|&t|{
+			let r=(t-relative_body.time).to_ratio();
+			Ratio::new(r.num,r.den)
+		});
 		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
 		let mut best_edge=None;
 		let face_n=self.face_nd(contact_face_id).0;
@@ -710,8 +804,20 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge
 	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
+	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
-		crate::minimum_difference::contains_point(self,point)
+		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
+		// Bound::Included means that the surface of the mesh is included in the mesh
+		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
+	}
+	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
+		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
+		//movement must escape the mesh forwards and backwards in time,
+		//otherwise the point is not inside the mesh
+		self.infinity_in(infinity_body)
+    	.is_some_and(|_|
+			self.infinity_in(-infinity_body)
+    		.is_some()
+     	)
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -750,12 +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/push_solve.rs

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

engine/session/Cargo.toml

@@ -10,6 +10,3 @@ strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../physics", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../../lib/snf", registry = "strafesnet" }
-
-[lints]
-workspace = true

engine/session/src/session.rs

@@ -31,7 +31,7 @@ pub enum SessionInputInstruction{
 	Mouse(glam::IVec2),
 	SetControl(strafesnet_common::physics::SetControlInstruction),
 	Mode(ImplicitModeInstruction),
-	Misc(MiscInstruction),
+	Misc(strafesnet_common::physics::MiscInstruction),
 }
 /// Implicit mode instruction are fed separately to session.
 /// Session generates the explicit mode instructions interlaced with a SetSensitivity instruction
@@ -152,10 +152,10 @@ enum ViewState{
 pub struct Session{
 	directories:Directories,
 	user_settings:UserSettings,
-	mouse_interpolator:MouseInterpolator,
+	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
 	view_state:ViewState,
 	//gui:GuiState
-	geometry_shared:PhysicsData,
+	geometry_shared:physics::PhysicsData,
 	simulation:Simulation,
 	// below fields not included in lite session
 	recording:Recording,
@@ -172,7 +172,7 @@ impl Session{
 			user_settings,
 			directories,
 			mouse_interpolator:MouseInterpolator::new(),
-			geometry_shared:PhysicsData::empty(),
+			geometry_shared:Default::default(),
 			simulation,
 			view_state:ViewState::Play,
 			recording:Default::default(),
@@ -184,7 +184,7 @@ impl Session{
 	}
 	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
 		self.simulation.physics.clear();
-		self.geometry_shared=PhysicsData::new(map);
+		self.geometry_shared.generate_models(map);
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{

engine/settings/Cargo.toml

@@ -8,6 +8,3 @@ configparser = "3.0.2"
 directories = "6.0.0"
 glam = "0.30.0"
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-
-[lints]
-workspace = true

integration-testing/Cargo.toml

@@ -4,12 +4,6 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam = "0.30.0"
 strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }
-# this is just for the primitive constructor
-strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }
-
-[lints]
-workspace = true

integration-testing/src/main.rs

@@ -3,8 +3,6 @@ mod util;
 
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod test_scenes;
 
 use std::time::Instant;
 
@@ -31,8 +29,9 @@ fn run_replay()->Result<(),ReplayError>{
 	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
 
 	// create recording
+	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	let physics_data=PhysicsData::new(&map);
+	physics_data.generate_models(&map);
 	println!("simulating...");
 	let mut physics=PhysicsState::default();
 	for ins in bot.instructions{
@@ -140,8 +139,9 @@ fn test_determinism()->Result<(),ReplayError>{
 	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
 	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
 
+	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	let physics_data=PhysicsData::new(&map);
+	physics_data.generate_models(&map);
 
 	let (send,recv)=std::sync::mpsc::channel();
 

integration-testing/src/test_scenes.rs

@@ -1,117 +0,0 @@
-use strafesnet_physics::physics::{InternalInstruction,PhysicsData,PhysicsState,PhysicsContext};
-use strafesnet_common::gameplay_modes::NormalizedModes;
-use strafesnet_common::gameplay_attributes::{CollisionAttributes,CollisionAttributesId};
-use strafesnet_common::integer::{vec3,mat3,Planar64Affine3,Time};
-use strafesnet_common::model::{Mesh,Model,MeshId,ModelId,RenderConfigId};
-use strafesnet_common::map::CompleteMap;
-use strafesnet_rbx_loader::primitives::{unit_cube,CubeFaceDescription};
-
-struct TestSceneBuilder{
-	meshes:Vec<Mesh>,
-	models:Vec<Model>,
-}
-impl TestSceneBuilder{
-	fn new()->Self{
-		Self{
-			meshes:Vec::new(),
-			models:Vec::new(),
-		}
-	}
-	fn push_mesh(&mut self,mesh:Mesh)->MeshId{
-		let mesh_id=self.meshes.len();
-		self.meshes.push(mesh);
-		MeshId::new(mesh_id as u32)
-	}
-	fn push_mesh_instance(&mut self,mesh:MeshId,transform:Planar64Affine3)->ModelId{
-		let model=Model{
-			mesh,
-			attributes:CollisionAttributesId::new(0),
-			color:glam::Vec4::ONE,
-			transform,
-		};
-		let model_id=self.models.len();
-		self.models.push(model);
-		ModelId::new(model_id as u32)
-	}
-	fn build(self)->PhysicsData{
-		let modes=NormalizedModes::new(Vec::new());
-		let attributes=vec![CollisionAttributes::contact_default()];
-		let meshes=self.meshes;
-		let models=self.models;
-		let textures=Vec::new();
-		let render_configs=Vec::new();
-		PhysicsData::new(&CompleteMap{
-			modes,
-			attributes,
-			meshes,
-			models,
-			textures,
-			render_configs,
-		})
-	}
-}
-
-fn test_scene()->PhysicsData{
-	let mut builder=TestSceneBuilder::new();
-	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
-	let mesh=builder.push_mesh(unit_cube(cube_face_description));
-	// place two 5x5x5 cubes.
-	builder.push_mesh_instance(mesh,Planar64Affine3::new(
-		mat3::from_diagonal(vec3::int(5,5,5)>>1),
-		vec3::int(0,0,0)
-	));
-	builder.push_mesh_instance(mesh,Planar64Affine3::new(
-		mat3::from_diagonal(vec3::int(5,5,5)>>1),
-		vec3::int(5,-5,0)
-	));
-	builder.build()
-}
-
-#[test]
-fn simultaneous_collision(){
-	let physics_data=test_scene();
-	let body=strafesnet_physics::physics::Body::new(
-		(vec3::int(5+2,0,0)>>1)+vec3::int(1,1,0),
-		vec3::int(-1,-1,0),
-		vec3::int(0,0,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	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.
-	// See multi-collision branch
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
-	assert!(phys_iter.next().is_none());
-	let body=physics.body();
-	assert_eq!(body.position,vec3::int(5,0,0));
-	assert_eq!(body.velocity,vec3::int(0,0,0));
-	assert_eq!(body.acceleration,vec3::int(0,0,0));
-	assert_eq!(body.time,Time::from_secs(1));
-}
-#[test]
-fn bug_3(){
-	let physics_data=test_scene();
-	let body=strafesnet_physics::physics::Body::new(
-		(vec3::int(5+2,0,0)>>1)+vec3::int(1,2,0),
-		vec3::int(-1,-1,0),
-		vec3::int(0,0,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	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

@@ -10,8 +10,9 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
 
 	// create recording
+	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	let physics_data=PhysicsData::new(&map);
+	physics_data.generate_models(&map);
 	println!("simulating...");
 
 	//teleport to bug
@@ -29,7 +30,7 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	// wait one second to activate the bug
 	// hit=Some(ModelId(2262))
 	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
-		time:Time::from_millis(500),
+		time:strafesnet_common::integer::Time::from_millis(500),
 		instruction:strafesnet_common::physics::Instruction::Idle,
 	});
 
@@ -44,8 +45,9 @@ fn physics_bug_3()->Result<(),ReplayError>{
 	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
 
 	// create recording
+	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	let physics_data=PhysicsData::new(&map);
+	physics_data.generate_models(&map);
 	println!("simulating...");
 
 	//teleport to bug
@@ -68,7 +70,7 @@ fn physics_bug_3()->Result<(),ReplayError>{
 	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),
+		time:strafesnet_common::integer::Time::from_millis(500),
 		instruction:strafesnet_common::physics::Instruction::Idle,
 	});
 

lib/bsp_loader/Cargo.toml

@@ -17,6 +17,3 @@ vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
 vpk = "0.3.0"
-
-[lints]
-workspace = true

lib/bsp_loader/src/brush.rs

@@ -7,7 +7,7 @@ use crate::{valve_transform_normal,valve_transform_dist};
 #[derive(Hash,Eq,PartialEq)]
 struct Face{
 	normal:integer::Planar64Vec3,
-	dot:Planar64,
+	dot:integer::Planar64,
 }
 
 #[derive(Debug)]
@@ -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,
 				});
@@ -347,7 +347,7 @@ pub struct PartialMap1{
 	modes:NormalizedModes,
 }
 impl PartialMap1{
-	pub fn add_prop_meshes(
+	pub fn add_prop_meshes<'a>(
 		self,
 		prop_meshes:Meshes<model::Mesh>,
 	)->PartialMap2{

lib/bsp_loader/src/loader.rs

@@ -31,7 +31,7 @@ impl Loader for TextureLoader{
 	type Error=TextureError;
 	type Index<'a>=Cow<'a,str>;
 	type Resource=Texture;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let file_name=format!("textures/{}.dds",index);
 		let mut file=std::fs::File::open(file_name)?;
 		let mut data=Vec::new();
@@ -111,7 +111,7 @@ impl ModelLoader<'_,'_>{
 		}
 	}
 }
-impl Loader for ModelLoader<'_,'_>{
+impl<'bsp,'vpk> Loader for ModelLoader<'bsp,'vpk>{
 	type Error=MeshError;
 	type Index<'a>=&'a str where Self:'a;
 	type Resource=vmdl::Model;
@@ -151,7 +151,7 @@ impl MeshLoader<'_,'_,'_,'_>{
 		}
 	}
 }
-impl Loader for MeshLoader<'_,'_,'_,'_>{
+impl<'str,'bsp,'vpk,'load> Loader for MeshLoader<'bsp,'vpk,'load,'str>{
 	type Error=MeshError;
 	type Index<'a>=&'a str where Self:'a;
 	type Resource=Mesh;

lib/bsp_loader/src/mesh.rs

@@ -61,7 +61,7 @@ pub fn convert_mesh(model:vmdl::Model,deferred_loader:&mut RenderConfigDeferredL
 						_=>None,
 					}
 				})
-			}).filter_map(|[v1,v2,v3]|{
+			}).flat_map(|[v1,v2,v3]|{
 				// this should probably be a fatal error :D
 				let v1=model_vertices.get(v1)?;
 				let v2=model_vertices.get(v2)?;

lib/common/Cargo.toml

@@ -17,6 +17,3 @@ linear_ops = { version = "0.1.1", path = "../linear_ops", registry = "strafesnet
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-
-[lints]
-workspace = true

lib/common/src/aabb.rs

@@ -2,9 +2,7 @@ use crate::integer::{vec3,Planar64Vec3};
 
 #[derive(Clone)]
 pub struct Aabb{
-	// min is inclusive
 	min:Planar64Vec3,
-	// max is not inclusive
 	max:Planar64Vec3,
 }
 
@@ -45,7 +43,7 @@ impl Aabb{
 	}
 	#[inline]
 	pub fn contains(&self,point:Planar64Vec3)->bool{
-		let bvec=self.min.le(point)&point.lt(self.max);
+		let bvec=self.min.lt(point)&point.lt(self.max);
 		bvec.all()
 	}
 	#[inline]
@@ -61,11 +59,11 @@ impl Aabb{
 	pub fn center(&self)->Planar64Vec3{
 		self.min.map_zip(self.max,|(min,max)|min.midpoint(max))
 	}
-	#[inline]
+	//probably use floats for area & volume because we don't care about precision
-	pub fn area_weight(&self)->fixed_wide::fixed::Fixed<2,64>{
+	// pub fn area_weight(&self)->f32{
-		let d=self.max-self.min;
+	// 	let d=self.max-self.min;
-		d.x*d.y+d.y*d.z+d.z*d.x
+	// 	d.x*d.y+d.y*d.z+d.z*d.x
-	}
+	// }
 	// pub fn volume(&self)->f32{
 	// 	let d=self.max-self.min;
 	// 	d.x*d.y*d.z

lib/common/src/bvh.rs

@@ -245,19 +245,18 @@ pub fn generate_bvh<T>(boxen:Vec<(T,Aabb)>)->BvhNode<T>{
 
 fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 	let n=boxen.len();
-	const MAX_TERMINAL_BRANCH_LEAF_NODES:usize=20;
+	if force||n<20{
-	if force||n<MAX_TERMINAL_BRANCH_LEAF_NODES{
+		let mut aabb=Aabb::default();
-		let mut aabb_outer=Aabb::default();
+		let nodes=boxen.into_iter().map(|b|{
-		let nodes=boxen.into_iter().map(|(data,aabb)|{
+			aabb.join(&b.1);
-			aabb_outer.join(&aabb);
 			BvhNode{
-				content:RecursiveContent::Leaf(data),
+				content:RecursiveContent::Leaf(b.0),
-				aabb,
+				aabb:b.1,
 			}
 		}).collect();
 		BvhNode{
 			content:RecursiveContent::Branch(nodes),
-			aabb:aabb_outer,
+			aabb,
 		}
 	}else{
 		let mut sort_x=Vec::with_capacity(n);
@@ -273,9 +272,9 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 		sort_y.sort_by_key(|&(_,c)|c);
 		sort_z.sort_by_key(|&(_,c)|c);
 		let h=n/2;
-		let (_,median_x)=sort_x[h];
+		let median_x=sort_x[h].1;
-		let (_,median_y)=sort_y[h];
+		let median_y=sort_y[h].1;
-		let (_,median_z)=sort_z[h];
+		let median_z=sort_z[h].1;
 		//locate a run of values equal to the median
 		//partition point gives the first index for which the predicate evaluates to false
 		let first_index_eq_median_x=sort_x.partition_point(|&(_,x)|x<median_x);
@@ -314,10 +313,10 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 			};
 			list_list[list_id].push((data,aabb));
 		}
+		let mut aabb=Aabb::default();
 		if list_list.len()==1{
 			generate_bvh_node(list_list.remove(0),true)
 		}else{
-			let mut aabb=Aabb::default();
 			BvhNode{
 				content:RecursiveContent::Branch(
 					list_list.into_iter().map(|b|{

lib/common/src/gameplay_style.rs

@@ -34,7 +34,7 @@ pub struct StyleModifiers{
 	//unused
 	pub mass:Planar64,
 }
-impl Default for StyleModifiers{
+impl std::default::Default for StyleModifiers{
 	fn default()->Self{
 		Self::roblox_bhop()
 	}
@@ -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(){
+			if cr==crate::integer::vec3::ZERO_2{
-				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(){
+			if cr==crate::integer::vec3::ZERO_2{
-				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/instruction.rs

@@ -34,41 +34,12 @@ pub trait InstructionFeedback<I,T>:InstructionEmitter<I,Time=T>+InstructionConsu
 			self.process_instruction(instruction);
 		}
 	}
-	#[inline]
-	fn into_iter(self,time_limit:T)->InstructionIter<I,T,Self>
-		where
-			Self:Sized
-	{
-		InstructionIter{
-			time_limit,
-			feedback:self,
-			_phantom:core::marker::PhantomData,
-		}
-	}
 }
-impl<I,T,F> InstructionFeedback<I,T> for F
+impl<I,T,X> InstructionFeedback<I,T> for X
 	where
 		T:Copy,
-		F:InstructionEmitter<I,Time=T>+InstructionConsumer<I,Time=T>,
+		X:InstructionEmitter<I,Time=T>+InstructionConsumer<I,Time=T>,
 {}
-pub struct InstructionIter<I,T:Copy,F:InstructionFeedback<I,T>>{
-	time_limit:T,
-	feedback:F,
-	_phantom:core::marker::PhantomData<I>,
-}
-impl<I,T,F> Iterator for InstructionIter<I,T,F>
-	where
-		I:Clone,
-		T:Clone+Copy,
-		F:InstructionFeedback<I,T>,
-{
-	type Item=TimedInstruction<I,T>;
-	fn next(&mut self)->Option<Self::Item>{
-		let instruction=self.feedback.next_instruction(self.time_limit)?;
-		self.feedback.process_instruction(instruction.clone());
-		Some(instruction)
-	}
-}
 
 //PROPER PRIVATE FIELDS!!!
 pub struct InstructionCollector<I,T>{

lib/common/src/integer.rs

@@ -86,7 +86,7 @@ impl<T> std::fmt::Display for Time<T>{
 		write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
 	}
 }
-impl<T> Default for Time<T>{
+impl<T> std::default::Default for Time<T>{
 	fn default()->Self{
 		Self::raw(0)
 	}
@@ -126,7 +126,7 @@ impl_time_additive_assign_operator!(core::ops::AddAssign,add_assign);
 impl_time_additive_assign_operator!(core::ops::SubAssign,sub_assign);
 impl_time_additive_assign_operator!(core::ops::RemAssign,rem_assign);
 impl<T> std::ops::Mul for Time<T>{
-	type Output=Ratio<Fixed<2,64>,Fixed<2,64>>;
+	type Output=Ratio<fixed_wide::fixed::Fixed<2,64>,fixed_wide::fixed::Fixed<2,64>>;
 	#[inline]
 	fn mul(self,rhs:Self)->Self::Output{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
@@ -156,7 +156,7 @@ impl<T> core::ops::Mul<Time<T>> for Planar64{
 #[cfg(test)]
 mod test_time{
 	use super::*;
-	type Time=AbsoluteTime;
+	type Time=super::AbsoluteTime;
 	#[test]
 	fn time_from_planar64(){
 		let a:Time=Planar64::from(1).into();
@@ -552,7 +552,7 @@ impl TryFrom<[f32;3]> for Unit32Vec3{
 }
 */
 
-pub type Planar64TryFromFloatError=FixedFromFloatError;
+pub type Planar64TryFromFloatError=fixed_wide::fixed::FixedFromFloatError;
 pub type Planar64=fixed_wide::types::I32F32;
 pub type Planar64Vec3=linear_ops::types::Vector3<Planar64>;
 pub type Planar64Mat3=linear_ops::types::Matrix3<Planar64>;
@@ -561,6 +561,12 @@ pub mod vec3{
 	pub use linear_ops::types::Vector3;
 	pub const MIN:Planar64Vec3=Planar64Vec3::new([Planar64::MIN;3]);
 	pub const MAX:Planar64Vec3=Planar64Vec3::new([Planar64::MAX;3]);
+	pub const ZERO:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO;3]);
+	pub const ZERO_2:linear_ops::types::Vector3<Fixed::<2,64>>=linear_ops::types::Vector3::new([Fixed::<2,64>::ZERO;3]);
+	pub const ZERO_3:linear_ops::types::Vector3<Fixed::<3,96>>=linear_ops::types::Vector3::new([Fixed::<3,96>::ZERO;3]);
+	pub const ZERO_4:linear_ops::types::Vector3<Fixed::<4,128>>=linear_ops::types::Vector3::new([Fixed::<4,128>::ZERO;3]);
+	pub const ZERO_5:linear_ops::types::Vector3<Fixed::<5,160>>=linear_ops::types::Vector3::new([Fixed::<5,160>::ZERO;3]);
+	pub const ZERO_6:linear_ops::types::Vector3<Fixed::<6,192>>=linear_ops::types::Vector3::new([Fixed::<6,192>::ZERO;3]);
 	pub const X:Planar64Vec3=Planar64Vec3::new([Planar64::ONE,Planar64::ZERO,Planar64::ZERO]);
 	pub const Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ONE,Planar64::ZERO]);
 	pub const Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::ONE]);
@@ -569,10 +575,6 @@ pub mod vec3{
 	pub const NEG_Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::NEG_ONE,Planar64::ZERO]);
 	pub const NEG_Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::NEG_ONE]);
 	pub const NEG_ONE:Planar64Vec3=Planar64Vec3::new([Planar64::NEG_ONE,Planar64::NEG_ONE,Planar64::NEG_ONE]);
-	// TODO: use #![feature(generic_const_items)] when stabilized https://github.com/rust-lang/rust/issues/113521
-	pub const fn zero<const N:usize,const F:usize>()->Vector3<Fixed<N,F>>{
-		Vector3::new([Fixed::ZERO;3])
-	}
 	#[inline]
 	pub const fn int(x:i32,y:i32,z:i32)->Planar64Vec3{
 		Planar64Vec3::new([Planar64::raw((x as i64)<<32),Planar64::raw((y as i64)<<32),Planar64::raw((z as i64)<<32)])
@@ -661,7 +663,7 @@ pub struct Planar64Affine3{
 	pub translation:Planar64Vec3,
 }
 impl Planar64Affine3{
-	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::zero());
+	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::ZERO);
 	#[inline]
 	pub const fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
 		Self{matrix3,translation}

lib/deferred_loader/Cargo.toml

@@ -11,6 +11,3 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
-
-[lints]
-workspace = true

lib/deferred_loader/src/loader.rs

@@ -4,5 +4,5 @@ pub trait Loader{
 	type Error:Error;
 	type Index<'a> where Self:'a;
 	type Resource;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>;
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>;
 }

lib/fixed_wide/Cargo.toml

@@ -18,6 +18,3 @@ bnum = "0.13.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
-
-[lints]
-workspace = true

lib/fixed_wide/src/fixed.rs

@@ -1,8 +1,6 @@
 use bnum::{BInt,cast::As};
 
-const BNUM_DIGIT_WIDTH:usize=64;
+#[derive(Clone,Copy,Debug,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
-
-#[derive(Clone,Copy,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
 /// A Fixed point number for which multiply operations widen the bits in the output. (when the wide-mul feature is enabled)
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
@@ -70,34 +68,6 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn midpoint(self,other:Self)->Self{
 		Self::from_bits(self.bits.midpoint(other.bits))
 	}
-	#[inline]
-	pub const fn min(self,other:Self)->Self{
-		Self::from_bits(self.bits.min(other.bits))
-	}
-	#[inline]
-	pub const fn max(self,other:Self)->Self{
-		Self::from_bits(self.bits.max(other.bits))
-	}
-	/// return the result of self*sign(other)
-	#[inline]
-	pub const fn mul_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else if other.is_zero(){
-			Fixed::ZERO
-		}else{
-			self
-		}
-	}
-	/// return the result of self/sign(other) (divide by zero does not change the sign)
-	#[inline]
-	pub const fn div_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else{
-			self
-		}
-	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it
@@ -129,6 +99,28 @@ impl_from!(
 	i8,i16,i32,i64,i128,isize
 );
 
+impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
+where
+		T:Copy,
+		BInt::<N>:From<T>,
+{
+	#[inline]
+	fn eq(&self,&other:&T)->bool{
+		self.bits.eq(&other.into())
+	}
+}
+
+impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
+	where
+		T:Copy,
+		BInt::<N>:From<T>,
+{
+	#[inline]
+	fn partial_cmp(&self,&other:&T)->Option<std::cmp::Ordering>{
+		self.bits.partial_cmp(&other.into())
+	}
+}
+
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;
 	#[inline]
@@ -294,23 +286,6 @@ macro_rules! impl_from_float {
 impl_from_float!(integer_decode_f32,f32,24);
 impl_from_float!(integer_decode_f64,f64,53);
 
-impl<const N:usize,const F:usize> core::fmt::Debug for Fixed<N,F>{
-	#[inline]
-	fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
-		let integral=self.as_bits().unsigned_abs()>>F;
-		let fractional=self.as_bits().unsigned_abs()&((bnum::BUint::<N>::ONE<<F)-bnum::BUint::<N>::ONE);
-		let leading_zeroes=(fractional.leading_zeros() as usize).saturating_sub(N*BNUM_DIGIT_WIDTH-F)>>2;
-		if self.is_negative(){
-			core::write!(f,"-")?;
-		}
-		if fractional.is_zero(){
-			core::write!(f,"{integral:x}.{}","0".repeat(leading_zeroes))
-		}else{
-			core::write!(f,"{integral:x}.{}{fractional:x}","0".repeat(leading_zeroes))
-		}
-	}
-}
-
 impl<const N:usize,const F:usize> core::fmt::Display for Fixed<N,F>{
 	#[inline]
 	fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
@@ -334,6 +309,16 @@ macro_rules! impl_additive_operator {
 				self.$method(other)
 			}
 		}
+		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
+			where
+				BInt::<N>:From<U>,
+		{
+			type Output = $output;
+			#[inline]
+			fn $method(self, other: U) -> Self::Output {
+				Self::from_bits(self.bits.$method(BInt::<N>::from(other).shl(F as u32)))
+			}
+		}
 	};
 }
 macro_rules! impl_additive_assign_operator {
@@ -344,6 +329,15 @@ macro_rules! impl_additive_assign_operator {
 				self.bits.$method(other.bits);
 			}
 		}
+		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
+		where
+				BInt::<N>:From<U>,
+		{
+			#[inline]
+			fn $method(&mut self, other: U) {
+				self.bits.$method(BInt::<N>::from(other).shl(F as u32));
+			}
+		}
 	};
 }
 

lib/fixed_wide/src/tests.rs

@@ -229,16 +229,3 @@ fn test_zeroes_deferred_division(){
 		])
 	);
 }
-
-#[test]
-fn test_debug(){
-	assert_eq!(format!("{:?}",I32F32::EPSILON),"0.00000001");
-	assert_eq!(format!("{:?}",I32F32::ONE),"1.00000000");
-	assert_eq!(format!("{:?}",I32F32::TWO),"2.00000000");
-	assert_eq!(format!("{:?}",I32F32::MAX),"7fffffff.ffffffff");
-	assert_eq!(format!("{:?}",I32F32::try_from(core::f64::consts::PI).unwrap()),"3.243f6a88");
-	assert_eq!(format!("{:?}",I32F32::NEG_EPSILON),"-0.00000001");
-	assert_eq!(format!("{:?}",I32F32::NEG_ONE),"-1.00000000");
-	assert_eq!(format!("{:?}",I32F32::NEG_TWO),"-2.00000000");
-	assert_eq!(format!("{:?}",I32F32::MIN),"-80000000.00000000");
-}

lib/linear_ops/Cargo.toml

@@ -20,6 +20,3 @@ paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]
 fixed_wide = { path = "../fixed_wide", registry = "strafesnet", features = ["wide-mul"] }
-
-[lints]
-workspace = true

lib/linear_ops/src/macros/matrix.rs

@@ -205,8 +205,7 @@ macro_rules! impl_matrix_named_fields_shape {
 			#[inline]
 			fn deref(&self)->&Self::Target{
 				// This cast is valid because Matrix has #[repr(transparent)]
-				let ptr:*const [[T;$size_inner];$size_outer]=&self.array;
+				let ptr=&self.array as *const [[T;$size_inner];$size_outer] as *const Self::Target;
-				let ptr=ptr as *const Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&*ptr}
 			}
@@ -215,8 +214,7 @@ macro_rules! impl_matrix_named_fields_shape {
 			#[inline]
 			fn deref_mut(&mut self)->&mut Self::Target{
 				// This cast is valid because Matrix has #[repr(transparent)]
-				let ptr:*mut [[T;$size_inner];$size_outer]=&mut self.array;
+				let ptr=&mut self.array as *mut [[T;$size_inner];$size_outer] as *mut Self::Target;
-				let ptr=ptr as *mut Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&mut*ptr}
 			}

lib/linear_ops/src/macros/vector.rs

@@ -331,8 +331,7 @@ macro_rules! impl_vector_named_fields {
 			#[inline]
 			fn deref(&self)->&Self::Target{
 				// This cast is valid because Vector has #[repr(transparent)]
-				let ptr:*const [T;$size]=&self.array;
+				let ptr=&self.array as *const [T;$size] as *const Self::Target;
-				let ptr=ptr as *const Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&*ptr}
 			}
@@ -341,8 +340,7 @@ macro_rules! impl_vector_named_fields {
 			#[inline]
 			fn deref_mut(&mut self)->&mut Self::Target{
 				// This cast is valid because Vector has #[repr(transparent)]
-				let ptr:*mut [T;$size]=&mut self.array;
+				let ptr=&mut self.array as *mut [T;$size] as *mut Self::Target;
-				let ptr=ptr as *mut Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&mut*ptr}
 			}

lib/ratio_ops/Cargo.toml

@@ -8,6 +8,3 @@ description = "Ratio operations using trait bounds for avoiding division like th
 authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
-
-[lints]
-workspace = true

lib/rbx_loader/Cargo.toml

@@ -12,17 +12,14 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false }
+lazy-regex = "3.1.0"
-rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
 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" }
+rbx_xml  = { version = "1.1.0-sn4", 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" }
-
-[lints]
-workspace = true

lib/rbx_loader/src/lib.rs

@@ -12,7 +12,7 @@ mod mesh;
 mod error;
 mod union;
 pub mod loader;
-pub mod primitives;
+mod primitives;
 
 pub mod data{
 	pub struct RobloxMeshBytes(Vec<u8>);

lib/rbx_loader/src/loader.rs

@@ -50,7 +50,7 @@ impl Loader for TextureLoader{
 	type Error=TextureError;
 	type Index<'a>=&'a str;
 	type Resource=Texture;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let RobloxAssetId(asset_id)=index.parse()?;
 		let file_name=format!("textures/{}.dds",asset_id);
 		let data=read_entire_file(file_name)?;
@@ -157,7 +157,7 @@ impl Loader for MeshLoader{
 	type Error=MeshError;
 	type Index<'a>=MeshIndex<'a>;
 	type Resource=MeshWithSize;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let mesh=match index.mesh_type{
 			MeshType::FileMesh=>{
 				let RobloxAssetId(asset_id)=index.content.parse()?;

lib/rbx_loader/src/mesh.rs

@@ -9,6 +9,7 @@ use crate::loader::MeshWithSize;
 
 #[derive(Debug)]
 pub enum Error{
+	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
 	RbxMesh(rbx_mesh::mesh::Error)
 }
 impl std::fmt::Display for Error{
@@ -21,43 +22,41 @@ impl std::error::Error for Error{}
 fn ingest_vertices2(
 	vertices:Vec<Vertex2>,
 	mb:&mut model::MeshBuilder,
-)->HashMap<rbx_mesh::mesh::VertexId2,VertexId>{
+)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>{
 	//this monster is collecting a map of old_vertices_index -> unique_vertices_index
 	//while also doing the inserting unique entries into lists simultaneously
-	// vertex positions that fail to convert are DROPPED
+	Ok(vertices.into_iter().enumerate().map(|(vertex_id,vertex)|Ok((
-	vertices.into_iter().enumerate().filter_map(|(vertex_id,vertex)|Some((
 		rbx_mesh::mesh::VertexId2(vertex_id as u32),
 		{
 			let vertex=IndexedVertex{
-				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos).ok()?),
+				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
 				tex:mb.acquire_tex_id(glam::Vec2::from_array(vertex.tex)),
-				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm).ok()?),
+				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
-				color:mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32))),
+				color:mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)))
 			};
 			mb.acquire_vertex_id(vertex)
 		}
-	))).collect()
+	))).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)
 }
 fn ingest_vertices_truncated2(
 	vertices:Vec<Vertex2Truncated>,
 	mb:&mut model::MeshBuilder,
 	static_color_id:ColorId,//pick one color and fill everything with it
-)->HashMap<rbx_mesh::mesh::VertexId2,VertexId>{
+)->Result<HashMap<rbx_mesh::mesh::VertexId2,VertexId>,Error>{
 	//this monster is collecting a map of old_vertices_index -> unique_vertices_index
 	//while also doing the inserting unique entries into lists simultaneously
-	// vertex positions that fail to convert are DROPPED
+	Ok(vertices.into_iter().enumerate().map(|(vertex_id,vertex)|Ok((
-	vertices.into_iter().enumerate().filter_map(|(vertex_id,vertex)|Some((
 		rbx_mesh::mesh::VertexId2(vertex_id as u32),
 		{
 			let vertex=IndexedVertex{
-				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos).ok()?),
+				pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
 				tex:mb.acquire_tex_id(glam::Vec2::from_array(vertex.tex)),
-				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm).ok()?),
+				normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
 				color:static_color_id,
 			};
 			mb.acquire_vertex_id(vertex)
 		}
-	))).collect()
+	))).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)
 }
 
 fn ingest_faces2_lods3(
@@ -68,8 +67,8 @@ fn ingest_faces2_lods3(
 ){
 	//faces have to be split into polygon groups based on lod
 	polygon_groups.extend(lods.windows(2).map(|lod_pair|
-		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().filter_map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
+		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
-			Some(vec![*vertex_id_map.get(&v0)?,*vertex_id_map.get(&v1)?,*vertex_id_map.get(&v2)?])
+			vec![vertex_id_map[&v0],vertex_id_map[&v1],vertex_id_map[&v2]]
 		).collect()))
 	))
 }
@@ -81,18 +80,18 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 	match rbx_mesh::read_versioned(roblox_mesh_bytes.cursor()).map_err(Error::RbxMesh)?{
 		rbx_mesh::mesh::Mesh::V1(mesh)=>{
 			let color_id=mb.acquire_color_id(glam::Vec4::ONE);
-			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.vertices.chunks_exact(3).filter_map(|trip|{
+			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.vertices.chunks_exact(3).map(|trip|{
 				let mut ingest_vertex1=|vertex:&rbx_mesh::mesh::Vertex1|{
 					let vertex=IndexedVertex{
-						pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos).ok()?),
+						pos:mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?),
 						tex:mb.acquire_tex_id(glam::vec2(vertex.tex[0],vertex.tex[1])),
-						normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm).ok()?),
+						normal:mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?),
 						color:color_id,
 					};
-					Some(mb.acquire_vertex_id(vertex))
+					Ok(mb.acquire_vertex_id(vertex))
 				};
-				Some(vec![ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?])
+				Ok(vec![ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?])
-			}).collect())));
+			}).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)));
 		},
 		rbx_mesh::mesh::Mesh::V2(mesh)=>{
 			let vertex_id_map=match mesh.header.sizeof_vertex{
@@ -102,10 +101,10 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 					ingest_vertices_truncated2(mesh.vertices_truncated,&mut mb,color_id)
 				},
 				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
-			};
+			}?;
 			//one big happy group for all the faces
-			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().filter_map(|face|
+			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|face|
-				Some(vec![*vertex_id_map.get(&face.0)?,*vertex_id_map.get(&face.1)?,*vertex_id_map.get(&face.2)?])
+				vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
 			).collect())));
 		},
 		rbx_mesh::mesh::Mesh::V3(mesh)=>{
@@ -115,15 +114,15 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 					ingest_vertices_truncated2(mesh.vertices_truncated,&mut mb,color_id)
 				},
 				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
-			};
+			}?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 		rbx_mesh::mesh::Mesh::V4(mesh)=>{
-			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb);
+			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb)?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 		rbx_mesh::mesh::Mesh::V5(mesh)=>{
-			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb);
+			let vertex_id_map=ingest_vertices2(mesh.vertices,&mut mb)?;
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 	}

lib/rbx_loader/src/rbx.rs

@@ -18,15 +18,6 @@ fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
 	rbx_dom_weak::ustr(s)
 }
 
-macro_rules! lazy_regex{
-	($r:literal)=>{{
-		use regex::Regex;
-		use std::sync::LazyLock;
-		static RE:LazyLock<Regex>=LazyLock::new(||Regex::new($r).unwrap());
-		&RE
-	}};
-}
-
 fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Result<Planar64Affine3,Planar64TryFromFloatError>{
 	Ok(Planar64Affine3::new(
 		Planar64Mat3::from_cols([
@@ -127,7 +118,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			);
 		},
 		other=>{
-			let regman=lazy_regex!(r"^(BonusStart|WormholeOut)(\d+)$");
+			let regman=lazy_regex::regex!(r"^(BonusStart|WormholeOut)(\d+)$");
 			if let Some(captures)=regman.captures(other){
 				match &captures[1]{
 					"BonusStart"=>{
@@ -153,7 +144,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					},
 					_=>(),
 				}
-			}else if let Some(captures)=lazy_regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
+			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
 				let stage_id=StageId::new(ParseIntContext::parse(&captures[3]).map_err(GetAttributesError::StageIdParseInt)?);
@@ -194,7 +185,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						stage_element,
 					),
 				);
-			}else if let Some(captures)=lazy_regex!(r"^(Jump|WormholeIn)(\d+)$")
+			}else if let Some(captures)=lazy_regex::regex!(r"^(Jump|WormholeIn)(\d+)$")
 			.captures(other){
 				match &captures[1]{
 					"Jump"=>modes_builder.push_mode_update(
@@ -219,7 +210,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					},
 					_=>unreachable!("regex2[1] messed up bad"),
 				}
-			}else if let Some(captures)=lazy_regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
+			}else if let Some(captures)=lazy_regex::regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
 			.captures(other){
 				force_can_collide=false;
 				force_intersecting=true;
@@ -251,7 +242,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{
@@ -344,12 +335,12 @@ pub struct RobloxFaceTextureDescription{
 	pub color:glam::Vec4,
 	pub transform:RobloxTextureTransform,
 }
-impl PartialEq for RobloxFaceTextureDescription{
+impl core::cmp::PartialEq for RobloxFaceTextureDescription{
 	fn eq(&self,other:&Self)->bool{
 		self.to_bits().eq(&other.to_bits())
 	}
 }
-impl Eq for RobloxFaceTextureDescription{}
+impl core::cmp::Eq for RobloxFaceTextureDescription{}
 impl core::hash::Hash for RobloxFaceTextureDescription{
 	fn hash<H:core::hash::Hasher>(&self,state:&mut H){
 		self.to_bits().hash(state);
@@ -775,10 +766,10 @@ struct MeshIdWithSize{
 	mesh:model::MeshId,
 	size:Planar64Vec3,
 }
-fn acquire_mesh_id_from_render_config_id(
+fn acquire_mesh_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	mesh_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RenderConfigId,model::MeshId>>,
-	loaded_meshes:&HashMap<model::MeshId,MeshWithSize>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_mesh_id:model::MeshId,
 	render:RenderConfigId,
 )->Option<MeshIdWithSize>{
@@ -798,10 +789,10 @@ fn acquire_mesh_id_from_render_config_id(
 		size,
 	})
 }
-fn acquire_union_id_from_render_config_id(
+fn acquire_union_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	union_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RobloxPartDescription,model::MeshId>>,
-	loaded_meshes:&HashMap<model::MeshId,MeshWithSize>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_union_id:model::MeshId,
 	part_texture_description:RobloxPartDescription,
 )->Option<MeshIdWithSize>{

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/rbxassetid/Cargo.toml

@@ -9,6 +9,3 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 url = "2.5.4"
-
-[lints]
-workspace = true

lib/roblox_emulator/Cargo.toml

@@ -13,12 +13,9 @@ run-service=[]
 
 [dependencies]
 glam = "0.30.0"
-mlua = { version = "0.11.3", features = ["luau"] }
+mlua = { version = "0.10.1", features = ["luau"] }
-phf = { version = "0.13.1", features = ["macros"] }
+phf = { version = "0.12.1", features = ["macros"] }
-rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
 rbx_reflection = "5.0.0"
 rbx_reflection_database = "1.0.0"
 rbx_types = "2.0.0"
-
-[lints]
-workspace = true

lib/roblox_emulator/src/runner/enum.rs

@@ -8,7 +8,7 @@ impl<'a> EnumItem<'a>{
 		Self{name:Some(name.as_ref()),value}
 	}
 }
-impl From<rbx_types::Enum> for EnumItem<'_>{
+impl<'a> From<rbx_types::Enum> for EnumItem<'a>{
 	fn from(e:rbx_types::Enum)->Self{
 		EnumItem{
 			name:None,
@@ -65,7 +65,7 @@ impl<'a> EnumItems<'a>{
 }
 
 pub enum CoerceEnum<'a>{
-	Integer(i64),
+	Integer(i32),
 	String(mlua::String),
 	Enum(EnumItem<'a>),
 }

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

@@ -5,12 +5,12 @@ use rbx_types::Ref;
 use rbx_dom_weak::{Ustr,InstanceBuilder,WeakDom};
 
 use crate::util::static_ustr;
+use crate::runner::vector3::Vector3;
 use crate::runner::number::Number;
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 	//class functions store
 	lua.set_app_data(ClassMethodsStore::default());
-	lua.set_app_data(InstanceValueStore::default());
 
 	let table=lua.create_table()?;
 
@@ -43,7 +43,7 @@ pub fn class_is_a(class:&str,superclass:&str)->bool{
 	};
 	db.has_superclass(class,superclass)
 }
-fn get_full_name(dom:&WeakDom,instance:&rbx_dom_weak::Instance)->String{
+fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
 	let mut full_name=instance.name.clone();
 	let mut pref=instance.parent();
 	while let Some(parent)=dom.get_by_ref(pref){
@@ -65,28 +65,28 @@ pub fn get_name_source(lua:&mlua::Lua,script:Instance)->Result<(String,String),m
 	})
 }
 
-pub fn find_first_child<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_child<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.name==name)
 }
-pub fn find_first_descendant<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_descendant<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
 	dom.descendants_of(instance.referent()).find(|&inst|inst.name==name)
 }
 
-pub fn find_first_child_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_child_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.class==class)
 }
-pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_descendant_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
 	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
 }
 
-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>{
+pub fn find_first_child_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
 	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>{
+pub fn find_first_descendant_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
 	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
@@ -325,16 +325,13 @@ impl mlua::UserData for Instance{
 				}
 
 				//find or create an associated userdata object
-				if let Some(value)=instance_value_store_mut(lua,|ivs|{
+				let instance=this.get_mut(dom)?;
-					//TODO: walk class tree somehow
+				if let Some(value)=get_or_create_userdata(instance,lua,index_str)?{
-					match ivs.get_or_create_instance_values(&instance){
-						Some(mut instance_values)=>instance_values.get_or_create_value(lua,index_str),
-						None=>Ok(None)
-					}
-				})?{
 					return value.into_lua(lua);
 				}
+				// drop mutable borrow
 				//find a child with a matching name
+				let instance=this.get(dom)?;
 				find_first_child(dom,instance,index_str)
 				.map(|instance|Instance::new_unchecked(instance.referent()))
 				.into_lua(lua)
@@ -422,7 +419,7 @@ impl mlua::UserData for Instance{
 						rbx_types::Variant::CFrame(typed_value.clone().into())
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::ContentId)=>{
-						let typed_value=value.as_string().ok_or_else(||mlua::Error::runtime("Expected string"))?.to_str()?.to_owned();
+						let typed_value=value.as_str().ok_or_else(||mlua::Error::runtime("Expected string"))?.to_owned();
 						rbx_types::Variant::ContentId(typed_value.into())
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::Ref)=>{
@@ -487,8 +484,8 @@ static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
 		"GetService"=>GET_SERVICE,
 	},
 	"Terrain"=>phf::phf_map!{
-		"FillBall"=>cf!(|_lua,_,_:(crate::runner::vector3::Vector3,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
+		"FillBall"=>cf!(|_lua,_,_:(Vector3,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
-		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,crate::runner::vector3::Vector3,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
+		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Vector3,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
 		"FillCylinder"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Number,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
 		"SetMaterialColor"=>cf!(|_lua,_,_:(crate::runner::r#enum::CoerceEnum,crate::runner::color3::Color3)|mlua::Result::Ok(())),
 	},
@@ -609,8 +606,6 @@ fn find_virtual_property(
 }
 
 // lazy-loaded per-instance userdata values
-// This whole thing is a bad idea and a garbage collection nightmare.
-// TODO: recreate rbx_dom_weak with my own instance type that owns this data.
 type CreateUserData=fn(&mlua::Lua)->mlua::Result<mlua::AnyUserData>;
 type LUD=phf::Map<&'static str,// Class name
 	phf::Map<&'static str,// Value name
@@ -643,47 +638,22 @@ static LAZY_USER_DATA:LUD=phf::phf_map!{
 		"MouseClick"=>create_script_signal,
 	},
 };
-#[derive(Default)]
+fn get_or_create_userdata(instance:&mut rbx_dom_weak::Instance,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
-pub struct InstanceValueStore{
+	use std::collections::hash_map::Entry;
-	values:HashMap<Ref,
+	let db=rbx_reflection_database::get();
-		HashMap<&'static str,
+	let Some(class)=db.classes.get(instance.class.as_str())else{
-			mlua::AnyUserData
+		return Ok(None)
-		>
+	};
-	>,
+	if let Some((&static_str,create_userdata))=db.superclasses_iter(class).find_map(|superclass|
-}
+		// find pair (class,index)
-pub struct InstanceValues<'a>{
+		LAZY_USER_DATA.get(&superclass.name)
-	named_values:&'static phf::Map<&'static str,CreateUserData>,
+		.and_then(|map|map.get_entry(index))
-	values:&'a mut HashMap<&'static str,mlua::AnyUserData>,
+	){
-}
+		let index_ustr=static_ustr(static_str);
-impl InstanceValueStore{
+		return Ok(Some(match instance.userdata.entry(index_ustr){
-	pub fn get_or_create_instance_values(&mut self,instance:&rbx_dom_weak::Instance)->Option<InstanceValues<'_>>{
+			Entry::Occupied(entry)=>entry.get().clone(),
-		LAZY_USER_DATA.get(instance.class.as_str())
+			Entry::Vacant(entry)=>entry.insert(create_userdata(lua)?).clone(),
-			.map(|named_values|
+		}));
-				InstanceValues{
-					named_values,
-					values:self.values.entry(instance.referent())
-					.or_insert_with(||HashMap::new()),
-				}
-			)
 	}
-}
+	Ok(None)
-impl InstanceValues<'_>{
-	pub fn get_or_create_value(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
-		Ok(match self.named_values.get_entry(index){
-			Some((&static_index_str,&function_pointer))=>Some(
-				match self.values.entry(static_index_str){
-					Entry::Occupied(entry)=>entry.get().clone(),
-					Entry::Vacant(entry)=>entry.insert(
-						function_pointer(lua)?
-					).clone(),
-				}
-			),
-			None=>None,
-		})
-	}
-}
-
-pub fn instance_value_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut InstanceValueStore)->mlua::Result<T>)->mlua::Result<T>{
-	let mut cf=lua.app_data_mut::<InstanceValueStore>().ok_or_else(||mlua::Error::runtime("InstanceValueStore missing"))?;
-	f(&mut *cf)
 }

lib/roblox_emulator/src/runner/number.rs

@@ -4,7 +4,7 @@
 
 #[derive(Clone,Copy)]
 pub enum Number{
-	Integer(i64),
+	Integer(i32),
 	Number(f64),
 }
 macro_rules! impl_ty{

lib/roblox_emulator/src/runner/runner.rs

@@ -1,4 +1,5 @@
 use crate::context::Context;
+use crate::util::static_ustr;
 #[cfg(feature="run-service")]
 use crate::scheduler::scheduler_mut;
 
@@ -48,11 +49,6 @@ fn init(lua:&mlua::Lua)->mlua::Result<()>{
 	Ok(())
 }
 
-unsafe fn extend_lifetime_mut<'a,T>(src:&mut T)->&'a mut T{
-	let ptr:*mut T=src;
-	unsafe{&mut*ptr}
-}
-
 impl Runner{
 	pub fn new()->Result<Self,Error>{
 		let runner=Self{
@@ -70,7 +66,8 @@ impl Runner{
 		// SAFETY: This is not a &'static mut WeakDom,
 		// but as long as Runnable<'a> holds the lifetime of &'a mut Context
 		// it is a valid unique reference.
-		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{extend_lifetime_mut(&mut context.dom)});
+		let ptr=&mut context.dom as *mut rbx_dom_weak::WeakDom;
+		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{&mut*ptr});
 		#[cfg(feature="run-service")]
 		self.lua.set_app_data::<crate::scheduler::Scheduler>(crate::scheduler::Scheduler::default());
 		Ok(Runnable{
@@ -129,20 +126,15 @@ impl Runnable<'_>{
 	}
 	#[cfg(feature="run-service")]
 	pub fn run_service_step(&self)->Result<(),mlua::Error>{
-		let render_stepped=super::instance::instance::dom_mut(&self.lua,|dom|{
+		let render_stepped_signal=super::instance::instance::dom_mut(&self.lua,|dom|{
 			let run_service=super::instance::instance::find_first_child_of_class(dom,dom.root(),"RunService").ok_or_else(||mlua::Error::runtime("RunService missing"))?;
-			super::instance::instance::instance_value_store_mut(&self.lua,|instance_value_store|{
+			Ok(match run_service.userdata.get(&static_ustr("RenderStepped")){
-				//unwrap because I trust my find_first_child_of_class function to
+				Some(render_stepped)=>Some(render_stepped.borrow::<super::script_signal::ScriptSignal>()?.clone()),
-				let mut instance_values=instance_value_store.get_or_create_instance_values(run_service).ok_or_else(||mlua::Error::runtime("RunService InstanceValues missing"))?;
+				None=>None
-				let render_stepped=instance_values.get_or_create_value(&self.lua,"RenderStepped")?;
-				//let stepped=instance_values.get_or_create_value(&self.lua,"Stepped")?;
-				//let heartbeat=instance_values.get_or_create_value(&self.lua,"Heartbeat")?;
-				Ok(render_stepped)
 			})
 		})?;
-		if let Some(render_stepped)=render_stepped{
+		if let Some(render_stepped_signal)=render_stepped_signal{
-			let signal:&super::script_signal::ScriptSignal=&*render_stepped.borrow()?;
+			render_stepped_signal.fire(&mlua::MultiValue::new());
-			signal.fire(&mlua::MultiValue::new());
 		}
 		Ok(())
 	}

lib/roblox_emulator/src/runner/script_signal.rs

@@ -117,7 +117,7 @@ impl mlua::FromLua for ScriptSignal{
 }
 
 impl mlua::UserData for ScriptConnection{
-	fn add_fields<F:UserDataFields<Self>>(fields:&mut F){
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
 		fields.add_field_method_get("Connected",|_,this|{
 			Ok(this.position().is_some())
 		});

lib/roblox_emulator/src/scheduler.rs

@@ -46,8 +46,8 @@ impl Scheduler{
 	}
 }
 
-pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut Scheduler)->mlua::Result<T>)->mlua::Result<T>{
+pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut crate::scheduler::Scheduler)->mlua::Result<T>)->mlua::Result<T>{
-	let mut scheduler=lua.app_data_mut::<Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
+	let mut scheduler=lua.app_data_mut::<crate::scheduler::Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
 	f(&mut *scheduler)
 }
 

lib/snf/Cargo.toml

@@ -9,6 +9,3 @@ edition = "2024"
 binrw = "0.15.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
-
-[lints]
-workspace = true

lib/snf/src/bot.rs

@@ -6,7 +6,7 @@ use strafesnet_common::physics::Time;
 
 const VERSION:u32=0;
 
-type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,Time>;
+type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::Time>;
 
 #[derive(Debug)]
 pub enum Error{
@@ -274,7 +274,7 @@ pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:i
 
 	//probe header length
 	let mut bot_header_data=Vec::new();
-	header.write_le(&mut std::io::Cursor::new(&mut bot_header_data)).map_err(Error::InvalidData)?;
+	binrw::BinWrite::write_le(&header,&mut std::io::Cursor::new(&mut bot_header_data)).map_err(Error::InvalidData)?;
 
 	// the first block location is the map header
 	block_location.push(offset);

lib/snf/src/map.rs

@@ -97,8 +97,8 @@ enum ResourceType{
 }
 
 struct ResourceMap<T>{
-	meshes:HashMap<model::MeshId,T>,
+	meshes:HashMap<strafesnet_common::model::MeshId,T>,
-	textures:HashMap<model::TextureId,T>,
+	textures:HashMap<strafesnet_common::model::TextureId,T>,
 }
 impl<T> Default for ResourceMap<T>{
 	fn default()->Self{
@@ -185,7 +185,7 @@ pub struct StreamableMap<R:BinReaderExt>{
 	//this is every possible attribute... need some sort of streaming system
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 	//this is every possible render configuration... shaders and such... need streaming
-	render_configs:Vec<model::RenderConfig>,
+	render_configs:Vec<strafesnet_common::model::RenderConfig>,
 	//this makes sense to keep in memory for streaming, a map of which blocks occupy what space
 	bvh:BvhNode<BlockId>,
 	//something something resources hashmaps
@@ -223,7 +223,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		}
 		Ok(Self{
 			file,
-			modes:gameplay_modes::NormalizedModes::new(modes),
+			modes:strafesnet_common::gameplay_modes::NormalizedModes::new(modes),
 			attributes,
 			render_configs,
 			bvh:strafesnet_common::bvh::generate_bvh(bvh),
@@ -366,12 +366,12 @@ fn collect_spacial_blocks(
 		block_location.push(sequential_block_data.position());
 	}else{
 		match bvh_node.into_content(){
-			RecursiveContent::Branch(bvh_node_list)=>{
+			strafesnet_common::bvh::RecursiveContent::Branch(bvh_node_list)=>{
 				for bvh_node in bvh_node_list{
 					collect_spacial_blocks(block_location,block_headers,sequential_block_data,bvh_node)?;
 				}
 			},
-			RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
+			strafesnet_common::bvh::RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
 		}
 	}
 	Ok(())
@@ -384,13 +384,13 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 	let boxen=map.models.into_iter().enumerate().map(|(model_id,model)|{
 		//grow your own aabb
 		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
-		let mut aabb=Aabb::default();
+		let mut aabb=strafesnet_common::aabb::Aabb::default();
 		for &pos in &mesh.unique_pos{
 			aabb.grow(model.transform.transform_point3(pos).narrow_1().unwrap());
 		}
 		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
-	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|size_of::<newtypes::model::Model>());
+	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|std::mem::size_of::<newtypes::model::Model>());
 	//build blocks
 	//block location is initialized with two values
 	//the first value represents the location of the first byte after the file header

lib/snf/src/newtypes/physics.rs

@@ -20,7 +20,7 @@ impl TryInto<TimedPhysicsInstruction> for TimedInstruction{
 	}
 }
 impl TryFrom<TimedPhysicsInstruction> for TimedInstruction{
-	type Error=InstructionConvert;
+	type Error=super::physics::InstructionConvert;
 	fn try_from(value:TimedPhysicsInstruction)->Result<Self,Self::Error>{
 		Ok(Self{
 			time:value.time.get(),

map-tool/Cargo.toml

@@ -12,11 +12,12 @@ flate2 = "1.0.27"
 futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
-rbx_asset = { version = "0.5.0", registry = "strafesnet" }
+lazy-regex = "3.1.0"
-rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_asset = { version = "0.4.4", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet" }
 rbx_reflection_database = "1.0.0"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_xml = { version = "1.1.0-sn4", 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" }
@@ -35,6 +36,3 @@ vtf = "0.3.0"
 #lto = true
 #strip = true
 #codegen-units = 1
-
-[lints]
-workspace = true

map-tool/src/roblox.rs

@@ -465,7 +465,7 @@ fn convert_to_snf(path:&Path,output_folder:PathBuf)->Result<Errors,ConvertError>
 	})
 }
 
-async fn roblox_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf)->AResult<()>{
+async fn roblox_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf)->AResult<()>{
 	let start=std::time::Instant::now();
 
 	let thread_limit=std::thread::available_parallelism()?.get();

map-tool/src/source.rs

@@ -484,7 +484,7 @@ async fn convert_to_snf(path:&Path,vpk_list:&[strafesnet_bsp_loader::Vpk],output
 
 	Ok(())
 }
-async fn source_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf,vpk_paths:Vec<PathBuf>)->AResult<()>{
+async fn source_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf,vpk_paths:Vec<PathBuf>)->AResult<()>{
 	let start=std::time::Instant::now();
 
 	let thread_limit=std::thread::available_parallelism()?.get();

strafe-client/Cargo.toml

@@ -28,12 +28,9 @@ 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 = "26.0.1"
 winit = "0.30.7"
 
 [profile.dev]
 strip = false
 opt-level = 3
-
-[lints]
-workspace = true

strafe-client/src/setup.rs

@@ -119,13 +119,12 @@ impl<'a> SetupContextPartial3<'a>{
 
 		let (device, queue)=pollster::block_on(self.adapter
 			.request_device(
-				&wgpu::DeviceDescriptor{
+				&wgpu::DeviceDescriptor {
-					label:None,
+					label: None,
-					required_features:(optional_features&self.adapter.features())|required_features,
+					required_features: (optional_features & self.adapter.features()) | required_features,
-					required_limits:needed_limits,
+					required_limits: needed_limits,
 					memory_hints:wgpu::MemoryHints::Performance,
-					trace:wgpu::Trace::Off,
+					trace: wgpu::Trace::Off,
-					experimental_features:wgpu::ExperimentalFeatures::disabled(),
 				},
 			))
 			.expect("Unable to find a suitable GPU adapter!");

strafe-client/src/window.rs

@@ -188,7 +188,7 @@ impl WindowContext<'_>{
 		}
 	}
 
-	fn device_event(&mut self,time:SessionTime,event:winit::event::DeviceEvent){
+	fn device_event(&mut self,time:SessionTime,event: winit::event::DeviceEvent){
 		match event{
 			winit::event::DeviceEvent::MouseMotion{
 			    delta,