break to outer

engine/graphics/Cargo.toml

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

engine/graphics/src/graphics.rs

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

engine/physics/src/body.rs

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

engine/physics/src/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,895 +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 narrow_dir2(dir:Vector3<Fixed<2,64>>)->Planar64Vec3{
-	if dir==vec3::zero(){
-		return dir.narrow_1().unwrap();
-	}
-	let x=dir.x.as_bits().unsigned_abs().bits();
-	let y=dir.y.as_bits().unsigned_abs().bits();
-	let z=dir.z.as_bits().unsigned_abs().bits();
-	let big=x.max(y).max(z);
-	const MAX_BITS:u32=64+31;
-	if MAX_BITS<big{
-		dir>>(big-MAX_BITS)
-	}else{
-		dir
-	}.narrow_1().unwrap()
-}
-fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
-	if dir==vec3::zero(){
-		return dir.narrow_1().unwrap();
-	}
-	let x=dir.x.as_bits().unsigned_abs().bits();
-	let y=dir.y.as_bits().unsigned_abs().bits();
-	let z=dir.z.as_bits().unsigned_abs().bits();
-	let big=x.max(y).max(z);
-	const MAX_BITS:u32=96+31;
-	if MAX_BITS<big{
-		dir>>(big-MAX_BITS)
-	}else{
-		dir
-	}.narrow_1().unwrap()
-}
-
-fn reduce1<M:MeshQuery>(
-	[v0]:Simplex<1,M::Vert>,
-	mesh:&M,
-	point:Planar64Vec3,
-)->Reduced<M::Vert>{
-	// --debug.profilebegin("reduceSimplex0")
-	// local a = a1 - a0
-	let p0=mesh.vert(v0);
-
-	// local p = -a
-	let p=-(p0+point);
-
-	// local direction = p
-	let mut dir=p;
-
-	// if direction.magnitude == 0 then
-	// 	direction = chooseAnyDirection()
-	if dir==vec3::zero(){
-		dir=choose_any_direction();
-	}
-
-	// return direction, a0, a1
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery>(
-	[v0,v1]:Simplex<2,M::Vert>,
-	mesh:&M,
-	point:Planar64Vec3,
-)->Reduced<M::Vert>{
-	// --debug.profilebegin("reduceSimplex1")
-	// local a = a1 - a0
-	// local b = b1 - b0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
-
-	// local p = -a
-	// local u = b - a
-	let p=-(p0+point);
-	let u=p1-p0;
-
-	// -- modify to take into account the radiuses
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = u:Cross(p):Cross(u)
-		let direction=u.cross(p).cross(u);
-
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			return Reduced{
-				dir:choose_perpendicular_direction(u),
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			};
-		}
-
-		// -- modify the direction to take into account a0R and b0R
-		// return direction, a0, a1, b0, b1
-		return Reduced{
-			dir:narrow_dir3(direction),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		};
-	}
-
-	// local direction = p
-	let mut dir=p;
-
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		dir=choose_perpendicular_direction(u);
-	}
-
-	// return direction, a0, a1
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery>(
-	[v0,mut v1,v2]:Simplex<3,M::Vert>,
-	mesh:&M,
-	point:Planar64Vec3,
-)->Reduced<M::Vert>{
-	// --debug.profilebegin("reduceSimplex2")
-	// local a = a1 - a0
-	// local b = b1 - b0
-	// local c = c1 - c0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
-	let p2=mesh.vert(v2);
-
-	// local p = -a
-	// local u = b - a
-	// local v = c - a
-	let p=-(p0+point);
-	let mut u=p1-p0;
-	let v=p2-p0;
-
-	// local uv = u:Cross(v)
-	// local up = u:Cross(p)
-	// local pv = p:Cross(v)
-	// local uv_up = uv:Dot(up)
-	// local uv_pv = uv:Dot(pv)
-	let mut uv=u.cross(v);
-	let mut up=u.cross(p);
-	let pv=p.cross(v);
-	let uv_up=uv.dot(up);
-	let uv_pv=uv.dot(pv);
-
-	// if uv_up >= 0 and uv_pv >= 0 then
-	if !uv_up.is_negative()&&!uv_pv.is_negative(){
-		// local uvp = uv:Dot(p)
-		let uvp=uv.dot(p);
-
-		// local direction = uvp < 0 and -uv or uv
-		let direction=if uvp.is_negative(){
-			-uv
-		}else{
-			uv
-		};
-
-		// return direction, a0, a1, b0, b1, c0, c1
-		return Reduced{
-			dir:narrow_dir2(direction),
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		};
-	}
-
-	// local u_u = u:Dot(u)
-	// local v_v = v:Dot(v)
-	// local uDist = uv_up/(u_u*v.magnitude)
-	// local vDist = uv_pv/(v_v*u.magnitude)
-	// local minDist2 = math.min(uDist, vDist)
-	let u_dist=uv_up*v.length();
-	let v_dist=uv_pv*u.length();
-
-	// if vDist == minDist2 then
-	if v_dist<u_dist{
-		u=v;
-		up=-pv;
-		uv=-uv;
-		// b0 = c0
-		// b1 = c1
-		v1=v2;
-	}
-
-	// local p_u = p:Dot(u)
-	let p_u=p.dot(u);
-
-	// if p_u >= 0 then
-	if !p_u.is_negative(){
-		// local direction = up:Cross(u)
-		let direction=up.cross(u);
-		// if direction.magnitude == 0 then
-		if direction==vec3::zero(){
-			// direction = uv
-			return Reduced{
-				dir:narrow_dir2(uv),
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			};
-		}
-
-		// return direction, a0, a1, b0, b1
-		return Reduced{
-			dir:narrow_dir3(direction),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		};
-	}
-
-	// local direction = p
-	let dir=p;
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		// direction = uv
-		return Reduced{
-			dir:narrow_dir2(uv),
-			simplex:Simplex1_3::Simplex1([v0]),
-		};
-	}
-	// return direction, a0, a0
-	Reduced{
-		dir,
-		simplex:Simplex1_3::Simplex1([v0]),
-	}
-}
-
-// local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<M:MeshQuery>(
-	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
-	mesh:&M,
-	point:Planar64Vec3,
-)->Reduce<M::Vert>{
-	// --debug.profilebegin("reduceSimplex3")
-	// local a = a1 - a0
-	// local b = b1 - b0
-	// local c = c1 - c0
-	// local d = d1 - d0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
-	let p2=mesh.vert(v2);
-	let p3=mesh.vert(v3);
-
-	// local p = -a
-	// local u = b - a
-	// local v = c - a
-	// local w = d - a
-	let p=-(p0+point);
-	let mut u=p1-p0;
-	let mut v=p2-p0;
-	let w=p3-p0;
-
-	// local uv = u:Cross(v)
-	// local vw = v:Cross(w)
-	// local wu = w:Cross(u)
-	// local uvw = uv:Dot(w)
-	// local pvw = vw:Dot(p)
-	// local upw = wu:Dot(p)
-	// local uvp = uv:Dot(p)
-	let mut uv=u.cross(v);
-	let vw=v.cross(w);
-	let wu=w.cross(u);
-	let uv_w=uv.dot(w);
-	let pv_w=vw.dot(p);
-	let up_w=wu.dot(p);
-	let uv_p=uv.dot(p);
-
-	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
-	if !pv_w.div_sign(uv_w).is_negative()
-	 &&!up_w.div_sign(uv_w).is_negative()
-	 &&!uv_p.div_sign(uv_w).is_negative(){
-		// origin is contained, this is a positive detection
-		// local direction = Vector3.new(0, 0, 0)
-		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
-		return Reduce::Escape([v0,v1,v2,v3]);
-	}
-
-	// local uvwSign = uvw < 0 and -1 or uvw > 0 and 1 or 0
-	// local uvDist = uvp*uvwSign/uv.magnitude
-	// local vwDist = pvw*uvwSign/vw.magnitude
-	// local wuDist = upw*uvwSign/wu.magnitude
-	// local minDist3 = math.min(uvDist, vwDist, wuDist)
-	let uv_dist=uv_p.mul_sign(uv_w);
-	let vw_dist=pv_w.mul_sign(uv_w);
-	let wu_dist=up_w.mul_sign(uv_w);
-	let wu_len=wu.length();
-	let uv_len=uv.length();
-	let vw_len=vw.length();
-
-	if vw_dist*wu_len<wu_dist*vw_len{
-		// if vwDist == minDist3 then
-		if vw_dist*uv_len<uv_dist*vw_len{
-			(u,v)=(v,w);
-			uv=vw;
-			// uv_p=pv_w; // unused
-			// b0, c0 = c0, d0
-			// b1, c1 = c1, d1
-			(v1,v2)=(v2,v3);
-		}
-	}else{
-		// 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]
-		}
-	}
-
-	// 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
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
-		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			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
-			let dir=if uv_w.is_negative(){
-				narrow_dir2(uv)
-			}else{
-				narrow_dir2(-uv)
-			};
-			return Reduce::Reduced(Reduced{
-				dir,
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			});
-		}
-
-		// return direction, a0, a1, b0, b1
-		return Reduce::Reduced(Reduced{
-			dir:narrow_dir3(direction),
-			simplex:Simplex1_3::Simplex2([v0,v1]),
-		});
-	}
-
-	// local direction = p
-	let dir=p;
-	// if direction.magnitude == 0 then
-	if dir==vec3::zero(){
-		// direction = uvw < 0 and uv or -uv
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
-		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			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),
-		}
-	}
-}
-
-//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);
-					crawl_to_closest_ev(mesh,[v0,v1],point).into()
-				},
-				Simplex1_3::Simplex3([v0,v1,v2])=>{
-					// invert
-					let (v0,v1,v2)=(-v0,-v1,-v2);
-					// Shimmy to the side until you find a face that contains the closest point
-					// it's ALWAYS representable as a face, but this algorithm may
-					// return E or V in edge cases but I don't think that will break the face crawler
-					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
-				},
-			})
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
-			// let simplex=refine_to_exact(mesh,simplex);
-			None
-		},
-		// fast_fail value is irrelevant and will never be returned!
-		||unreachable!()
-	)
-}
-
-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
-	)
-}
-
-// local function minimumDifference(
-// 	queryP, radiusP,
-// 	queryQ, radiusQ,
-// 	exitRadius, testIntersection
-// )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
-	mesh:&M,
-	point:Planar64Vec3,
-	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
-	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
-	on_fast_fail:impl FnOnce()->T,
-)->T{
-	// local initialAxis = queryQ() - queryP()
-	// local new_point_p = queryP(initialAxis)
-	// local new_point_q = queryQ(-initialAxis)
-	// local direction, a0, a1, b0, b1, c0, c1, d0, d1
-	let mut initial_axis=mesh.hint_point()+point;
-	// degenerate case
-	if initial_axis==vec3::zero(){
-		initial_axis=choose_any_direction();
-	}
-	let last_point=mesh.farthest_vert(-initial_axis);
-	// this represents the 'a' value in the commented code
-	let mut last_pos=mesh.vert(last_point);
-	let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);
-
-	// exitRadius = testIntersection and 0 or exitRadius or 1/0
-	// for _ = 1, 100 do
-	loop{
-		// new_point_p = queryP(-direction)
-		// new_point_q = queryQ(direction)
-		// local next_point = new_point_q - new_point_p
-		let next_point=mesh.farthest_vert(direction);
-		let next_pos=mesh.vert(next_point);
-
-		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
-		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
-			return on_fast_fail();
-		}
-
-		let simplex_big=simplex_small.push_front(next_point);
-
-		// if
-		// 	direction:Dot(next_point - a) <= 0 or
-		// 	absDet(next_point, a, b, c) < 1e-6
-		if !direction.dot(next_pos-last_pos).is_positive()
-		||simplex_big.det_is_zero(mesh){
-			// Found enough information to compute the exact closest point.
-			// local norm = direction.unit
-			// local dist = a:Dot(norm)
-			// local hits = -dist < radiusP + radiusQ
-			let is_intersecting=(last_pos+point).dot(direction).is_positive();
-			return on_exact(is_intersecting,simplex_small);
-		}
-
-		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
-		match simplex_big.reduce(mesh,point){
-			// if a and b and c and d then
-			Reduce::Escape(simplex)=>{
-				// Enough information to conclude that the meshes are intersecting.
-				// Topology information is computed if needed.
-				return on_escape(simplex);
-			},
-			Reduce::Reduced(reduced)=>{
-				direction=reduced.dir;
-				simplex_small=reduced.simplex;
-			},
-		}
-
-		// next loop this will be a
-		last_pos=next_pos;
-	}
-}
-
-#[cfg(test)]
-mod test{
-	use super::*;
-    use crate::model::{PhysicsMesh,PhysicsMeshView};
-
-    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
-		const ENABLE_FAST_FAIL:bool=true;
-		// TODO: remove mesh negation
-		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
-			// on_exact
-			|is_intersecting,_simplex|{
-				is_intersecting
-			},
-			// on_escape
-			|_simplex|{
-				// intersection is guaranteed at this point
-				true
-			},
-			// fast_fail value
-			||false
-		)
-	}
-
-	#[test]
-	fn test_cube_points(){
-		let mesh=PhysicsMesh::unit_cube();
-		let mesh_view=mesh.complete_mesh_view();
-		for x in -2..=2{
-			for y in -2..=2{
-				for z in -2..=2{
-					let point=vec3::int(x,y,z)>>1;
-					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
-				}
-			}
-		}
-	}
-}

engine/physics/src/model.rs

@@ -90,9 +90,16 @@ 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;
+	/// Returns an iterator over the vertices in the direction of the directed edges.
+	/// Intended to be used to find adjacent vertices:
+	/// `self.directed_verts(self.vert_edges(vert_id).as_ref())`
+	/// TODO: rewrite this function as `adjacent_vertices`
+	fn directed_verts(&self,edges:&[Self::Edge])->impl Iterator<Item=Self::Vert>{
+		edges.iter().map(|e|{
+			let edge_verts=self.edge_verts(e.as_undirected());
+			edge_verts.as_ref()[e.parity() as usize]
+		})
+	}
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
 	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
 	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
@@ -103,21 +110,17 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
-	// I didn't write it down, but I assume the edges are directed
-	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
-	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//start, end
+	verts:[SubmeshVertId;2],//bottom, top
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
-	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -439,7 +442,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -454,27 +457,13 @@ 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;
 		self.data.verts[vert_idx].0
 	}
+	/// Directed edges going clockwise when looking in the direction of the face normal.
+	/// (Edit this documentation if this is wrong!)
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.topology.face_topology[face_id.get() as usize].edges.as_slice()
 	}
@@ -508,7 +497,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -526,6 +515,18 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
+	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;
@@ -543,21 +544,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)
@@ -584,19 +570,10 @@ 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
-impl core::ops::Neg for MinkowskiVert{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		match self{
-			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
-		}
-	}
-}
 #[derive(Clone,Copy,Debug)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
@@ -633,7 +610,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),
@@ -655,14 +632,6 @@ pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }
 
-// TODO: remove this
-impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
-	type Output=MinkowskiMesh<'a>;
-	fn neg(self)->Self::Output{
-		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
-	}
-}
-
 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
 		MinkowskiMesh{
@@ -670,32 +639,212 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let start_position=match range.start_bound(){
-			Bound::Included(time)=>relative_body.extrapolated_position(*time),
-			Bound::Excluded(time)=>relative_body.extrapolated_position(*time),
-			Bound::Unbounded=>relative_body.position,
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn closest_fev_not_inside(&self,relative_position:Planar64Vec3)->Option<FEV<MinkowskiMesh<'_>>>{
+		// Make a fast guess as to what the closest point will be.
+		let MinkowskiVert::VertVert(mut v0,mut v1)=self.farthest_vert(relative_position);
+		// TODO: alternate naive vertex searches to improve the robustness
+		// in the "tall bipyramid" failure case
+		let mut m0v=self.mesh0.vert(v0);
+		let mut m1v=self.mesh1.vert(v1);
+		let mut best_distance_squared={
+			let diff=relative_position+m1v-m0v;
+			diff.dot(diff)
 		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		//continue forwards along the body parabola
-		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		let mut v0e=self.mesh0.vert_edges(v0);
+		let mut v1e=self.mesh1.vert_edges(v1);
+		let mut v0e_ref=v0e.as_ref();
+		let mut v1e_ref=v1e.as_ref();
+		// repeatedly check adjacent vertex permutations to see if they are closer
+		loop{
+			let mut best_v0=None;
+			let mut best_v1=None;
+
+			// check vertices adjacent to v1 against v0
+			for m1_test_vert in self.mesh1.directed_verts(v1e_ref){
+				let m1v_test=self.mesh1.vert(m1_test_vert);
+				let diff=relative_position+m1v_test-m0v;
+				let d=diff.dot(diff);
+				if d<best_distance_squared{
+					best_distance_squared=d;
+					best_v0=None;
+					best_v1=Some(m1_test_vert);
+				}
+			}
+
+			// check vertices adjacent to v0 against v1
+			for m0_test_vert in self.mesh0.directed_verts(v0e_ref){
+				let m0v_test=self.mesh0.vert(m0_test_vert);
+				let diff=relative_position+m1v-m0v_test;
+				let d=diff.dot(diff);
+				if d<best_distance_squared{
+					best_distance_squared=d;
+					best_v0=Some(m0_test_vert);
+					best_v1=None;
+				}
+			}
+
+			// check permutations of adjacent vertices
+			for m0_test_vert in self.mesh0.directed_verts(v0e_ref){
+				let m0v_test=self.mesh0.vert(m0_test_vert);
+				for m1_test_vert in self.mesh1.directed_verts(v1e_ref){
+					let m1v_test=self.mesh1.vert(m1_test_vert);
+					let diff=relative_position+m1v_test-m0v_test;
+					let d=diff.dot(diff);
+					if d<best_distance_squared{
+						best_distance_squared=d;
+						best_v0=Some(m0_test_vert);
+						best_v1=Some(m1_test_vert);
+					}
+				}
+			}
+
+			// end condition
+			let v0_changed=match best_v0{
+				Some(new_v0)=>{
+					v0=new_v0;
+					m0v=self.mesh0.vert(v0);
+					v0e=self.mesh0.vert_edges(v0);
+					v0e_ref=v0e.as_ref();
+					true
+				},
+				None=>false,
+			};
+			let v1_changed=match best_v1{
+				Some(new_v1)=>{
+					v1=new_v1;
+					m1v=self.mesh1.vert(v1);
+					v1e=self.mesh1.vert_edges(v1);
+					v1e_ref=v1e.as_ref();
+					true
+				},
+				None=>false,
+			};
+			// if neither vertex changes, we found the closest two vertices.
+			if !(v0_changed&&v1_changed){
+				break;
+			}
+		}
+		// now you have the two closest vertices
+		let mut best_fev=FEV::Vert(MinkowskiVert::VertVert(v0,v1));
+		// ==== FEV::Edge ====
+		// test VertEdges
+		for &e1 in v1e_ref{
+			let edge_verts=self.mesh1.edge_verts(e1.as_undirected());
+			let &[ev0_id,ev1_id]=edge_verts.as_ref();
+			let (ev0,ev1)=(self.mesh1.vert(ev0_id),self.mesh1.vert(ev1_id));
+			let edge_n=ev1-ev0;
+			// use relative coordinates to make including relative_position easier
+			let diff=relative_position+m0v-ev0;
+			let d=diff.dot(edge_n);
+			// is test point between edge vertices
+			let edge_nn=edge_n.dot(edge_n);
+			if d.is_positive()&&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_distance_squared=distance_squared;
+					best_fev=FEV::Edge(MinkowskiEdge::VertEdge(v0,e1.as_undirected()))
+				}
+			}
+		}
+		// test EdgeVerts
+		for &e0 in v0e_ref{
+			let edge_verts=self.mesh0.edge_verts(e0.as_undirected());
+			let &[ev0_id,ev1_id]=edge_verts.as_ref();
+			let (ev0,ev1)=(self.mesh0.vert(ev0_id),self.mesh0.vert(ev1_id));
+			let edge_n=ev1-ev0;
+			// use relative coordinates to make including relative_position easier
+			let diff=m1v-relative_position-ev0;
+			let d=diff.dot(edge_n);
+			// is test point between edge vertices
+			let edge_nn=edge_n.dot(edge_n);
+			if d.is_positive()&&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_distance_squared=distance_squared;
+					best_fev=FEV::Edge(MinkowskiEdge::EdgeVert(e0.as_undirected(),v1))
+				}
+			}
+		}
+
+		// ==== FEV::Face ====
+		// test VertFaces
+		'outer: for &f1 in self.mesh1.vert_faces(v1).as_ref(){
+			let (n,d)=self.mesh1.face_nd(f1);
+			// Test the face's voronoi column
+			for &e1 in self.mesh1.face_edges(f1).as_ref(){
+				let edge_n=self.mesh1.directed_edge_n(e1);
+				let boundary_n=n.cross(edge_n);
+				let &[ev0_id,ev1_id]=self.mesh1.edge_verts(e1.as_undirected()).as_ref();
+				let (ev0,ev1)=(self.mesh1.vert(ev0_id),self.mesh1.vert(ev1_id));
+				let diff=(relative_position+m0v)*2-(ev0+ev1);
+				if boundary_n.dot(diff).is_negative(){
+					// The test point is outside the face's voronoi column.
+					continue 'outer;
+				}
+			}
+			// Calculate distance
+			let d=n.dot(relative_position+m0v)-d;
+			// Wrap for speed
+			let distance_squared=(d*d).wrap_2();
+			if distance_squared<best_distance_squared{
+				best_distance_squared=distance_squared;
+				best_fev=FEV::Face(MinkowskiFace::VertFace(v0,f1));
+			}
+		}
+		// test FaceVerts
+		'outer: for &f0 in self.mesh0.vert_faces(v0).as_ref(){
+			let (n,d)=self.mesh0.face_nd(f0);
+			// Test the face's voronoi column
+			for &e0 in self.mesh0.face_edges(f0).as_ref(){
+				let edge_n=self.mesh0.directed_edge_n(e0);
+				let boundary_n=n.cross(edge_n);
+				let &[ev0_id,ev1_id]=self.mesh0.edge_verts(e0.as_undirected()).as_ref();
+				let (ev0,ev1)=(self.mesh0.vert(ev0_id),self.mesh0.vert(ev1_id));
+				let diff=(m1v-relative_position)*2-(ev0+ev1);
+				if boundary_n.dot(diff).is_negative(){
+					// The test point is outside the face's voronoi column.
+					continue 'outer;
+				}
+			}
+			// Calculate distance
+			let d=n.dot(relative_position+m0v)-d;
+			// Wrap for speed
+			let distance_squared=(d*d).wrap_2();
+			if distance_squared<best_distance_squared{
+				best_distance_squared=distance_squared;
+				best_fev=FEV::Face(MinkowskiFace::FaceVert(f0,v1));
+			}
+		}
+		// test EdgeEdges
+		Some(best_fev)
+	}
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		self.closest_fev_not_inside(relative_body.position).and_then(|fev|{
+			//continue forwards along the body parabola
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		})
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// TODO: handle unbounded collision using infinity fev
-		let start_position=match upper_bound{
-			Bound::Included(time)=>relative_body.extrapolated_position(*time),
-			Bound::Excluded(time)=>relative_body.extrapolated_position(*time),
-			Bound::Unbounded=>relative_body.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
-		let infinity_body=-relative_body;
-		//continue backwards along the body parabola
-		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time))
+		self.closest_fev_not_inside(relative_body.position).and_then(|fev|{
+			//continue backwards along the body parabola
+			fev.crawl(self,&-relative_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+				//no need to test -time<time_limit because of the first step
+				.map(|(face,time)|(face,-time))
+		})
 	}
 	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		// TODO: make better
@@ -725,8 +874,10 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge
 	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		crate::minimum_difference::contains_point(self,point)
+	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
+		// TODO
+		println!("Unimplemented is_point_in_mesh called! {point}");
+		false
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -765,12 +916,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/src/session.rs

@@ -52,6 +52,7 @@ pub enum SessionControlInstruction{
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
+	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
@@ -149,7 +150,7 @@ enum ViewState{
 }
 
 pub struct Session{
-	directories:Option<Directories>,
+	directories:Directories,
 	user_settings:UserSettings,
 	mouse_interpolator:MouseInterpolator,
 	view_state:ViewState,
@@ -164,7 +165,7 @@ pub struct Session{
 impl Session{
 	pub fn new(
 		user_settings:UserSettings,
-		directories:Option<Directories>,
+		directories:Directories,
 		simulation:Simulation,
 	)->Self{
 		Self{
@@ -252,14 +253,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// don't flush the buffered instructions in the mouse interpolator
 				// until the mouse is confirmed to be not moving at a later time
 				// what if they pause for 5ms lmao
-				match &self.view_state{
-					ViewState::Play=>{
-						_=self.simulation.timer.set_paused(ins.time,paused);
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,paused);
-					},
-				}
+				_=self.simulation.timer.set_paused(ins.time,paused);
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -305,21 +299,19 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				match view_state{
 					ViewState::Play=>(),
 					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
-						if let Some(directories)=&self.directories{
-							let mut replays_path=directories.replays.clone();
-							let file_name=format!("{}.snfb",ins.time);
-							std::thread::spawn(move ||{
-								std::fs::create_dir_all(replays_path.as_path()).unwrap();
-								replays_path.push(file_name);
-								let file=std::fs::File::create(replays_path).unwrap();
-								strafesnet_snf::bot::write_bot(
-									std::io::BufWriter::new(file),
-									strafesnet_physics::VERSION.get(),
-									replay.recording.instructions
-								).unwrap();
-								println!("Finished writing bot file!");
-							});
-						}
+						let mut replays_path=self.directories.replays.clone();
+						let file_name=format!("{}.snfb",ins.time);
+						std::thread::spawn(move ||{
+							std::fs::create_dir_all(replays_path.as_path()).unwrap();
+							replays_path.push(file_name);
+							let file=std::fs::File::create(replays_path).unwrap();
+							strafesnet_snf::bot::write_bot(
+								std::io::BufWriter::new(file),
+								strafesnet_physics::VERSION.get(),
+								replay.recording.instructions
+							).unwrap();
+							println!("Finished writing bot file!");
+						});
 					},
 				}
 				_=self.simulation.timer.set_paused(ins.time,false);
@@ -382,6 +374,14 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 					},
 				}
 			},
+			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
+					},
+				}
+			}
 			Instruction::ChangeMap(complete_map)=>{
 				self.clear_recording();
 				self.change_map(complete_map);

integration-testing/src/test_scenes.rs

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

integration-testing/src/tests.rs

@@ -60,12 +60,8 @@ fn physics_bug_3()->Result<(),ReplayError>{
 		// vec3::raw_xyz(0,-96915585363,1265),
 		// vec3::raw_xyz(0,-429496729600,0),
 		// corner setup before wall hits
-		// vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
-		// vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
-		// vec3::raw_xyz(0,-429496729600,0),
-		// Actual bug 3 repro
-		vec3::raw_xyz(-2505538624455,3357963283914,557275711118),
-		vec3::raw_xyz(204188283920,-282280474198,166172785440),
+		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
 		vec3::raw_xyz(0,-429496729600,0),
 		Time::ZERO,
 	);

lib/bsp_loader/src/brush.rs

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

lib/bsp_loader/src/bsp.rs

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

lib/common/src/gameplay_style.rs

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

lib/common/src/integer.rs

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

lib/fixed_wide/src/fixed.rs

@@ -70,34 +70,6 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn midpoint(self,other:Self)->Self{
 		Self::from_bits(self.bits.midpoint(other.bits))
 	}
-	#[inline]
-	pub const fn min(self,other:Self)->Self{
-		Self::from_bits(self.bits.min(other.bits))
-	}
-	#[inline]
-	pub const fn max(self,other:Self)->Self{
-		Self::from_bits(self.bits.max(other.bits))
-	}
-	/// return the result of self*sign(other)
-	#[inline]
-	pub const fn mul_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else if other.is_zero(){
-			Fixed::ZERO
-		}else{
-			self
-		}
-	}
-	/// return the result of self/sign(other) (divide by zero does not change the sign)
-	#[inline]
-	pub const fn div_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else{
-			self
-		}
-	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it
@@ -129,6 +101,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]
@@ -334,6 +328,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 +348,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));
+			}
+		}
 	};
 }
 
@@ -366,7 +379,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 
 // This macro is not used in the default configuration.
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -545,7 +558,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

lib/rbx_loader/Cargo.toml

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

lib/rbx_loader/src/rbx.rs

@@ -251,7 +251,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}
 	}
 	//need some way to skip this
-	if allow_booster&&velocity!=vec3::zero(){
+	if allow_booster&&velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
 	Ok(match force_can_collide{
@@ -559,7 +559,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|

lib/rbx_loader/src/union.rs

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

lib/roblox_emulator/Cargo.toml

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

lib/roblox_emulator/src/context.rs

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

lib/roblox_emulator/src/runner/enum.rs

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

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

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

map-tool/Cargo.toml

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

strafe-client/Cargo.toml

@@ -16,7 +16,6 @@ source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
-chrono = "0.4.39"
 glam = "0.30.0"
 parking_lot = "0.12.1"
 pollster = "0.4.0"
@@ -26,14 +25,10 @@ strafesnet_deferred_loader = { path = "../lib/deferred_loader", registry = "stra
 strafesnet_graphics = { path = "../engine/graphics", registry = "strafesnet" }
 strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", optional = true }
-strafesnet_roblox_bot_file = { version = "0.8.1", registry = "strafesnet" }
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wasm-bindgen = "0.2.99"
-wasm-bindgen-futures = "0.4.49"
-web-sys = { version = "0.3.76", features = ["console"] }
-wgpu = "28.0.0"
+wgpu = "27.0.0"
 winit = "0.30.7"
 
 [profile.dev]

strafe-client/models/teslacyberv3.0.mtl

@@ -0,0 +1,62 @@
+# Blender MTL File: 'teslacyberv3.0.blend'
+# Material Count: 6
+
+newmtl Material
+Ns 65.476285
+Ka 1.000000 1.000000 1.000000
+Kd 0.411568 0.411568 0.411568
+Ks 0.614679 0.614679 0.614679
+Ke 0.000000 0.000000 0.000000
+Ni 36.750000
+d 1.000000
+illum 3
+
+newmtl Материал
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2
+
+newmtl Материал.001
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.026240 0.026240 0.026240
+Ks 0.000000 0.000000 0.000000
+Ke 0.000000 0.000000 0.000000
+Ni 1.450000
+d 1.000000
+illum 1
+
+newmtl Материал.002
+Ns 0.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.031837 0.032429 0.029425
+Ks 0.169725 0.169725 0.169725
+Ke 0.000000 0.000000 0.000000
+Ni 0.000000
+d 1.000000
+illum 2
+
+newmtl Материал.003
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.023585 0.083235 0.095923
+Ks 1.000000 1.000000 1.000000
+Ke 0.000000 0.000000 0.000000
+Ni 45.049999
+d 1.000000
+illum 3
+
+newmtl Материал.004
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2

strafe-client/src/app.rs

@@ -4,12 +4,12 @@ use strafesnet_common::instruction::TimedInstruction;
 use strafesnet_common::session::Time as SessionTime;
 
 pub struct App<'a>{
-	root_time:chrono::DateTime<chrono::Utc>,
+	root_time:std::time::Instant,
 	window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>,
 }
 impl<'a> App<'a>{
 	pub fn new(
-		root_time:chrono::DateTime<chrono::Utc>,
+		root_time:std::time::Instant,
 		window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>,
 	)->App<'a>{
 		Self{
@@ -18,7 +18,7 @@ impl<'a> App<'a>{
 		}
 	}
 	fn send_timed_instruction(&mut self,instruction:Instruction){
-		let time=integer::Time::from_nanos((chrono::Utc::now()-self.root_time).num_nanoseconds().unwrap());
+		let time=integer::Time::from_nanos(self.root_time.elapsed().as_nanos() as i64);
 		self.window_thread.send(TimedInstruction{time,instruction}).unwrap();
 	}
 }

strafe-client/src/compat_worker.rs

@@ -2,11 +2,11 @@ pub type QNWorker<'a,Task>=CompatNWorker<'a,Task>;
 pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
 
 pub struct CompatNWorker<'a,Task>{
-	f:Box<dyn FnMut(Task)+'a>,
+	f:Box<dyn FnMut(Task)+Send+'a>,
 }
 
 impl<'a,Task> CompatNWorker<'a,Task>{
-	pub fn new(f:impl FnMut(Task)+'a)->CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
 		Self{
 			f:Box::new(f),
 		}

strafe-client/src/file.rs

@@ -87,13 +87,10 @@ pub enum LoadFormat{
 	Bot(strafesnet_snf::bot::Segment),
 }
 
-pub fn load_file<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
+pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 	//blocking because it's simpler...
 	let file=std::fs::File::open(path).map_err(LoadError::File)?;
-	load(file)
-}
-pub fn load<R:Read+std::io::Seek>(reader:R)->Result<LoadFormat,LoadError>{
-	match read(reader).map_err(LoadError::ReadError)?{
+	match read(file).map_err(LoadError::ReadError)?{
 		#[cfg(feature="snf")]
 		ReadFormat::SNFB(bot)=>Ok(LoadFormat::Bot(bot)),
 		#[cfg(feature="snf")]

strafe-client/src/graphics_worker.rs

@@ -33,12 +33,12 @@ pub fn new(
 			},
 			Instruction::Resize(size,user_settings)=>{
 				println!("Resizing to {:?}",size);
-				//let t0=std::time::Instant::now();
+				let t0=std::time::Instant::now();
 				config.width=size.width.max(1);
 				config.height=size.height.max(1);
 				surface.configure(&device,&config);
 				graphics.resize(&device,&config,&user_settings);
-				//println!("Resize took {:?}",t0.elapsed());
+				println!("Resize took {:?}",t0.elapsed());
 			}
 			Instruction::Render(frame_state)=>{
 				//this has to go deeper somehow

strafe-client/src/main.rs

@@ -9,8 +9,5 @@ mod graphics_worker;
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 
 fn main(){
-	#[cfg(target_arch="wasm32")]
-	wasm_bindgen_futures::spawn_local(setup::setup_and_start(TITLE));
-	#[cfg(not(target_arch="wasm32"))]
-	pollster::block_on(setup::setup_and_start(TITLE));
+	setup::setup_and_start(TITLE);
 }

strafe-client/src/physics_worker.rs

@@ -1,15 +1,13 @@
 use crate::graphics_worker::Instruction as GraphicsInstruction;
 use strafesnet_settings::{directories::Directories,settings};
 use strafesnet_session::session::{
-	FrameState,
 	Session,Simulation,SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction,ImplicitModeInstruction,
 	Instruction as SessionInstruction,
 };
-use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::physics::{Time as PhysicsTime,TimeInner as PhysicsTimeInner};
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::timer::{Scaled,Timer,TimerState};
-use strafesnet_physics::physics::PhysicsData;
+use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
+use strafesnet_common::physics::Time as PhysicsTime;
+use strafesnet_common::session::Time as SessionTime;
+use strafesnet_common::timer::Timer;
 
 pub enum Instruction{
 	SessionInput(SessionInputInstruction),
@@ -21,136 +19,12 @@ pub enum Instruction{
 	LoadReplay(strafesnet_snf::bot::Segment),
 }
 
-fn vector3_to_glam(v:&strafesnet_roblox_bot_file::v0::Vector3)->glam::Vec3{
-	glam::vec3(v.x,v.y,v.z)
-}
-fn f32_to_p64(f:f32)->strafesnet_common::integer::Planar64{
-	f.try_into().unwrap_or(strafesnet_common::integer::Planar64::ZERO)
-}
-
-struct PlayBacker{
-	//Instructions
-	timelines:strafesnet_roblox_bot_file::v0::Block,
-	//"Simulation"
-	event_id:usize,
-	offset:f64,
-	duration:f64,
-	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-	physics_data:PhysicsData,
-	camera_offset:strafesnet_common::integer::Planar64Vec3,
-}
-impl PlayBacker{
-	pub fn new(
-		physics_data:PhysicsData,
-		timelines:strafesnet_roblox_bot_file::v0::Block,
-		camera_offset:strafesnet_common::integer::Planar64Vec3,
-	)->Self{
-		let first=timelines.output_events.first().unwrap();
-		let last=timelines.output_events.last().unwrap();
-		Self{
-			offset:first.time,
-			duration:last.time-first.time,
-			timelines,
-			event_id:0,
-			timer:Timer::from_state(Scaled::identity(),false),
-			physics_data,
-			camera_offset,
-		}
-	}
-	pub fn handle_instruction(&mut self,TimedInstruction{time,instruction}:&TimedInstruction<SessionInstruction,SessionTime>){
-		//match the instruction so the playback is pausable :D
-		match instruction{
-			&SessionInstruction::Control(SessionControlInstruction::SetPaused(paused))=>{
-				let _=self.timer.set_paused(*time,paused);
-			},
-			_=>(),
-		}
-		let simulation_time=self.timer.time(*time);
-		let mut time_float=simulation_time.get() as f64/PhysicsTime::ONE_SECOND.get() as f64+self.offset;
-		loop{
-			match self.timelines.output_events.get(self.event_id+1){
-				Some(next_event)=>{
-					if next_event.time<time_float{
-						self.event_id+=1;
-					}else{
-						break;
-					}
-				},
-				None=>{
-					//reset playback
-					self.event_id=0;
-					self.offset-=self.duration;
-					time_float-=self.duration;
-				},
-			}
-		}
-	}
-	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
-		use strafesnet_physics::physics::{Body,PhysicsCamera};
-
-		let time=self.timer.time(time);
-		let event0=&self.timelines.output_events[self.event_id];
-		let event1=&self.timelines.output_events[self.event_id+1];
-		let p0=vector3_to_glam(&event0.event.position);
-		let p1=vector3_to_glam(&event1.event.position);
-		let v0=vector3_to_glam(&event0.event.velocity);
-		let v1=vector3_to_glam(&event1.event.velocity);
-		let a0=vector3_to_glam(&event0.event.acceleration);
-		let a1=vector3_to_glam(&event1.event.acceleration);
-		let t0=event0.time;
-		let t1=event1.time;
-		let time_float=time.get() as f64/PhysicsTime::ONE_SECOND.get() as f64;
-		let t=((time_float+self.offset-t0)/(t1-t0)) as f32;
-		let p=p0.lerp(p1,t).to_array().map(f32_to_p64);
-		let v=v0.lerp(v1,t).to_array().map(f32_to_p64);
-		let a=a0.lerp(a1,t).to_array().map(f32_to_p64);
-
-		//println!("position={:?}",p);
-
-		let angles0=vector3_to_glam(&event0.event.angles);
-		let angles1=vector3_to_glam(&event1.event.angles);
-		let angles=angles0.lerp(angles1,t);
-		// mask mantissa out and set it to minimum value
-		// let ax_epsilon=f32::from_bits(angles.x.to_bits()&!((1<<23)-1)|1);
-		// let ay_epsilon=f32::from_bits(angles.y.to_bits()&!((1<<23)-1)|1);
-		let body=Body{
-			time,
-			position:strafesnet_common::integer::Planar64Vec3::new(p)+self.camera_offset,
-			velocity:strafesnet_common::integer::Planar64Vec3::new(v),
-			acceleration:strafesnet_common::integer::Planar64Vec3::new(a),
-		};
-		const FLOAT64_TO_ANGLE32_RADIANS:f64=((1i64<<31) as f64)/std::f64::consts::PI;
-		// xy is reversed in strafe client for some reason
-		let (ax,ay)=(
-			-angles.y as f64*FLOAT64_TO_ANGLE32_RADIANS,
-			-angles.x as f64*FLOAT64_TO_ANGLE32_RADIANS,
-		);
-		let camera=PhysicsCamera::new(
-			strafesnet_common::integer::Ratio64Vec2::new(1.0f32.try_into().unwrap(),1.0f32.try_into().unwrap()),
-			glam::ivec2(ax as i64 as i32,ay as i64 as i32)
-		);
-		FrameState{
-			body,
-			camera,
-			time,
-		}
-	}
-	pub fn user_settings(&self)->settings::UserSettings{
-		//oof, settings ignored
-		settings::UserSettings::default()
-	}
-	pub fn change_map(&mut self,_time:SessionTime,map:&strafesnet_common::map::CompleteMap){
-		self.physics_data=PhysicsData::new(&map);
-	}
-}
-
 pub fn new<'a>(
 	mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
-	directories:Option<Directories>,
+	directories:Directories,
 	user_settings:settings::UserSettings,
 )->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>{
 	let physics=strafesnet_physics::physics::PhysicsState::default();
-	let camera_offset=physics.style.camera_offset;
 	let timer=Timer::unpaused(SessionTime::ZERO,PhysicsTime::ZERO);
 	let simulation=Simulation::new(timer,physics);
 	let mut session=Session::new(
@@ -158,20 +32,11 @@ pub fn new<'a>(
 		directories,
 		simulation,
 	);
-	//load bot
-	let physics=PhysicsData::empty();
-	let data=include_bytes!("/home/quat/strafesnet/roblox_bot_file/files/bhop_marble_7cf33a64-7120-4514-b9fa-4fe29d9523d");
-	let bot_file=strafesnet_roblox_bot_file::v0::read_all_to_block(std::io::Cursor::new(data)).unwrap();
-	let mut interpolator=PlayBacker::new(
-		physics,
-		bot_file,
-		camera_offset,
-	);
 	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTime>|{
 		// excruciating pain
 		macro_rules! run_session_instruction{
 			($time:expr,$instruction:expr)=>{
-				interpolator.handle_instruction(&TimedInstruction{
+				session.process_instruction(TimedInstruction{
 					time:$time,
 					instruction:$instruction,
 				});
@@ -194,17 +59,16 @@ pub fn new<'a>(
 			},
 			Instruction::Render=>{
 				run_session_instruction!(ins.time,SessionInstruction::Idle);
-				if let Some(frame_state)=Some(interpolator.get_frame_state(ins.time)){
+				if let Some(frame_state)=session.get_frame_state(ins.time){
 					run_graphics_worker_instruction!(GraphicsInstruction::Render(frame_state));
 				}
 			},
 			Instruction::Resize(physical_size)=>{
 				run_session_instruction!(ins.time,SessionInstruction::Idle);
-				let user_settings=interpolator.user_settings().clone();
+				let user_settings=session.user_settings().clone();
 				run_graphics_worker_instruction!(GraphicsInstruction::Resize(physical_size,user_settings));
 			},
 			Instruction::ChangeMap(complete_map)=>{
-				interpolator.change_map(ins.time,&complete_map);
 				run_session_instruction!(ins.time,SessionInstruction::ChangeMap(&complete_map));
 				run_session_instruction!(ins.time,SessionInstruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId::MAIN,strafesnet_common::gameplay_modes::StageId::FIRST))));
 				run_graphics_worker_instruction!(GraphicsInstruction::ChangeMap(complete_map));

strafe-client/src/setup.rs

@@ -20,16 +20,6 @@ struct SetupContextPartial1{
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
 	let mut attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
-	#[cfg(target_arch="wasm32")]
-	{
-		use wasm_bindgen::JsCast;
-		use winit::platform::web::WindowAttributesExtWebSys;
-		let canvas=web_sys::window().unwrap()
-		.document().unwrap()
-		.get_element_by_id("canvas").unwrap()
-		.dyn_into::<web_sys::HtmlCanvasElement>().unwrap();
-		attr=attr.with_canvas(Some(canvas));
-	}
 	event_loop.create_window(attr)
 }
 fn create_instance()->SetupContextPartial1{
@@ -54,20 +44,43 @@ struct SetupContextPartial2<'a>{
 	surface:wgpu::Surface<'a>,
 }
 impl<'a> SetupContextPartial2<'a>{
-	async fn pick_adapter(self)->SetupContextPartial3<'a>{
+	fn pick_adapter(self)->SetupContextPartial3<'a>{
 		let adapter;
 
 		//TODO: prefer adapter that implements optional features
 		//let optional_features=optional_features();
 		let required_features=required_features();
 
-		let chosen_adapter=self.instance.request_adapter(&wgpu::RequestAdapterOptions{
-			power_preference:wgpu::PowerPreference::HighPerformance,
-			force_fallback_adapter:false,
-			compatible_surface:Some(&self.surface),
-		}).await;
+		//no helper function smh gotta write it myself
+		let adapters=self.instance.enumerate_adapters(self.backends);
+
+		let mut chosen_adapter=None;
+		let mut chosen_adapter_score=0;
+		for adapter in adapters {
+			if !adapter.is_surface_supported(&self.surface) {
+				continue;
+			}
+
+			let score=match adapter.get_info().device_type{
+				wgpu::DeviceType::IntegratedGpu=>3,
+				wgpu::DeviceType::DiscreteGpu=>4,
+				wgpu::DeviceType::VirtualGpu=>2,
+				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
+			};
+
+			let adapter_features=adapter.features();
+			if chosen_adapter_score<score&&adapter_features.contains(required_features) {
+				chosen_adapter_score=score;
+				chosen_adapter=Some(adapter);
+			}
+		}
+
+		if let Some(maybe_chosen_adapter)=chosen_adapter{
+			adapter=maybe_chosen_adapter;
+		}else{
+			panic!("No suitable GPU adapters found on the system!");
+		}
 
-		adapter=chosen_adapter.unwrap();
 
 		let adapter_info=adapter.get_info();
 		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
@@ -97,15 +110,14 @@ struct SetupContextPartial3<'a>{
 	adapter:wgpu::Adapter,
 }
 impl<'a> SetupContextPartial3<'a>{
-	async fn request_device(self)->SetupContextPartial4<'a>{
+	fn request_device(self)->SetupContextPartial4<'a>{
 		let optional_features=optional_features();
 		let required_features=required_features();
 
 		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
 		let needed_limits=strafesnet_graphics::graphics::required_limits().using_resolution(self.adapter.limits());
 
-		let trace_dir=std::env::var("WGPU_TRACE");
-		let (device, queue)=self.adapter
+		let (device, queue)=pollster::block_on(self.adapter
 			.request_device(
 				&wgpu::DeviceDescriptor{
 					label:None,
@@ -115,7 +127,7 @@ impl<'a> SetupContextPartial3<'a>{
 					trace:wgpu::Trace::Off,
 					experimental_features:wgpu::ExperimentalFeatures::disabled(),
 				},
-			).await
+			))
 			.expect("Unable to find a suitable GPU adapter!");
 
 		SetupContextPartial4{
@@ -157,7 +169,7 @@ pub struct SetupContext<'a>{
 	pub config:wgpu::SurfaceConfiguration,
 }
 
-pub async fn setup_and_start(title:&str){
+pub fn setup_and_start(title:&str){
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
 	println!("Initializing the surface...");
@@ -168,9 +180,9 @@ pub async fn setup_and_start(title:&str){
 
 	let partial_2=partial_1.create_surface(&window).unwrap();
 
-	let partial_3=partial_2.pick_adapter().await;
+	let partial_3=partial_2.pick_adapter();
 
-	let partial_4=partial_3.request_device().await;
+	let partial_4=partial_3.request_device();
 
 	let size=window.inner_size();
 
@@ -184,16 +196,16 @@ pub async fn setup_and_start(title:&str){
 		setup_context,
 	);
 
-	//for arg in std::env::args().skip(1){
+	for arg in std::env::args().skip(1){
 		window_thread.send(strafesnet_common::instruction::TimedInstruction{
 			time:strafesnet_common::integer::Time::ZERO,
-			instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile("".into())),
+			instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile(arg.into())),
 		}).unwrap();
-	//};
+	};
 
 	println!("Entering event loop...");
 	let mut app=crate::app::App::new(
-		chrono::Utc::now(),
+		std::time::Instant::now(),
 		window_thread
 	);
 	event_loop.run_app(&mut app).unwrap();

strafe-client/src/window.rs

@@ -15,7 +15,6 @@ pub enum Instruction{
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
 	mouse_pos:glam::DVec2,
-	simulation_paused:bool,
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTime>>,
@@ -25,50 +24,16 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<u32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x/2,self.screen_size.y/2)
 	}
-	fn free_mouse(&mut self){
-		self.manual_mouse_lock=false;
-		match self.window.set_cursor_position(self.get_middle_of_screen()){
-			Ok(())=>(),
-			Err(e)=>println!("Could not set cursor position: {:?}",e),
-		}
-		match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
-			Ok(())=>(),
-			Err(e)=>println!("Could not release cursor: {:?}",e),
-		}
-		self.window.set_cursor_visible(true);
-	}
-	fn lock_mouse(&mut self){
-		//if cursor is outside window don't lock but apparently there's no get pos function
-		//let pos=window.get_cursor_pos();
-		match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
-			Ok(())=>(),
-			Err(_)=>{
-				match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
-					Ok(())=>(),
-					Err(e)=>{
-						self.manual_mouse_lock=true;
-						println!("Could not confine cursor: {:?}",e)
-					},
-				}
-			}
-		}
-		self.window.set_cursor_visible(false);
-	}
 	fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
 		match event{
 			winit::event::WindowEvent::DroppedFile(path)=>{
-				let data=include_bytes!("/run/media/quat/Files/Documents/map-files/strafesnet/maps/bhop_snfm/5692093612.snfm");
-				match crate::file::load(std::io::Cursor::new(data)){
+				match crate::file::load(path.as_path()){
 					Ok(LoadFormat::Map(map))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}).unwrap(),
 					Ok(LoadFormat::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}).unwrap(),
 					Err(e)=>println!("Failed to load file: {e}"),
 				}
 			},
 			winit::event::WindowEvent::Focused(state)=>{
-				// don't unpause if manually paused
-				if self.simulation_paused{
-					return;
-				}
 				//pause unpause
 				self.physics_thread.send(TimedInstruction{
 					time,
@@ -81,8 +46,35 @@ impl WindowContext<'_>{
 				..
 			}=>{
 				match (logical_key,state){
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>self.free_mouse(),
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>self.lock_mouse(),
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>{
+						self.manual_mouse_lock=false;
+						match self.window.set_cursor_position(self.get_middle_of_screen()){
+							Ok(())=>(),
+							Err(e)=>println!("Could not set cursor position: {:?}",e),
+						}
+						match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+							Ok(())=>(),
+							Err(e)=>println!("Could not release cursor: {:?}",e),
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>{
+						//if cursor is outside window don't lock but apparently there's no get pos function
+						//let pos=window.get_cursor_pos();
+						match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
+							Ok(())=>(),
+							Err(_)=>{
+								match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+									Ok(())=>(),
+									Err(e)=>{
+										self.manual_mouse_lock=true;
+										println!("Could not confine cursor: {:?}",e)
+									},
+								}
+							}
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
 					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
 						if self.window.fullscreen().is_some(){
 							self.window.set_fullscreen(None);
@@ -140,16 +132,7 @@ impl WindowContext<'_>{
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
 							// TODO: bind system so playback pausing can use spacebar
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>if s{
-								let paused=!self.simulation_paused;
-								self.simulation_paused=paused;
-								if paused{
-									self.free_mouse();
-								}else{
-									self.lock_mouse();
-								}
-								Some(SessionInstructionSubset::Control(SessionControlInstruction::SetPaused(paused)))
-							}else{None},
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>session_playback!(TogglePaused,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_playback!(IncreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_playback!(DecreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_playback!(SkipBack,s),
@@ -237,21 +220,17 @@ impl WindowContext<'_>{
 		}
 	}
 }
-
 pub fn worker<'a>(
 	window:&'a winit::window::Window,
 	setup_context:crate::setup::SetupContext<'a>,
 )->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>{
 	// WindowContextSetup::new
 	#[cfg(feature="user-install")]
-	let directories=Directories::user();
+	let directories=Directories::user().unwrap();
 	#[cfg(not(feature="user-install"))]
-	let directories=Directories::portable().ok();
+	let directories=Directories::portable().unwrap();
 
-	let user_settings=match &directories{
-		Some(directories)=>directories.settings(),
-		None=>strafesnet_settings::settings::UserSettings::default(),
-	};
+	let user_settings=directories.settings();
 
 	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
 	graphics.load_user_settings(&user_settings);
@@ -262,7 +241,6 @@ pub fn worker<'a>(
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
 		mouse_pos:glam::DVec2::ZERO,
-		simulation_paused:false,
 		//make sure to update this!!!!!
 		screen_size,
 		window,

web-client/.gitignore

@@ -1 +0,0 @@
-/dist

web-client/Trunk.toml

@@ -1,2 +0,0 @@
-[build]
-target = "index.html"

web-client/index.html

@@ -1,47 +0,0 @@
-<!doctype html>
-<html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<meta
-			name="viewport"
-			content="width=device-width, height=device-height, initial-scale=1"
-		/>
-		<title>Strafe Client</title>
-
-		<base data-trunk-public-url />
-		<style type="text/css">
-			:focus {
-				outline: none;
-			}
-
-			body {
-				margin: 0px;
-				background: #fff;
-				width: 100%;
-				height: 100%;
-			}
-
-			#content {
-				/* This allows the flexbox to grow to max size, this is needed for WebGPU */
-				flex: 1 1 100%;
-				/* This forces CSS to ignore the width/height of the canvas, this is needed for WebGL */
-				contain: size;
-			}
-
-			.main-canvas {
-				margin: 0;
-				width: 100%;
-				height: 100%;
-			}
-		</style>
-	</head>
-	<body>
-		<canvas class="main-canvas" id="canvas"></canvas>
-		<link
-			data-trunk
-			rel="rust"
-			href="../strafe-client/Cargo.toml"
-			data-wasm-opt-params="--enable-bulk-memory --enable-nontrapping-float-to-int"
-		/>
-	</body>
-</html>