hack camera offset

Closes #13, but exposes the underlying issue at all times.

Reviewed-on: #14
Co-authored-by: Quaternions <krakow20@gmail.com>
Co-committed-by: Quaternions <krakow20@gmail.com>

engine/graphics/Cargo.toml

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

engine/graphics/src/graphics.rs

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

engine/physics/src/minimum_difference.rs

@@ -100,6 +100,37 @@ 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,
@@ -165,7 +196,7 @@ fn reduce2<M:MeshQuery>(
 		// -- modify the direction to take into account a0R and b0R
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir3(direction),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -231,7 +262,7 @@ fn reduce3<M:MeshQuery>(
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir2(direction),
 			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 		};
 	}
@@ -265,14 +296,14 @@ fn reduce3<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uv
 			return Reduced{
-				dir:uv.narrow_1().unwrap(),
+				dir:narrow_dir2(uv),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}
 
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir3(direction),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -283,7 +314,7 @@ fn reduce3<M:MeshQuery>(
 	if dir==vec3::zero(){
 		// direction = uv
 		return Reduced{
-			dir:uv.narrow_1().unwrap(),
+			dir:narrow_dir2(uv),
 			simplex:Simplex1_3::Simplex1([v0]),
 		};
 	}
@@ -336,8 +367,8 @@ fn reduce4<M:MeshQuery>(
 
 	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
 	if !pv_w.div_sign(uv_w).is_negative()
-	 ||!up_w.div_sign(uv_w).is_negative()
-	 ||!uv_p.div_sign(uv_w).is_negative(){
+	 &&!up_w.div_sign(uv_w).is_negative()
+	 &&!uv_p.div_sign(uv_w).is_negative(){
 		// origin is contained, this is a positive detection
 		// local direction = Vector3.new(0, 0, 0)
 		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
@@ -365,8 +396,6 @@ fn reduce4<M:MeshQuery>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
-		}else{
-			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -379,8 +408,6 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
-		}else{
-			v2=v3;
 		}
 	}
 
@@ -397,17 +424,15 @@ fn reduce4<M:MeshQuery>(
 	if !uv_up.is_negative()&&!uv_pv.is_negative(){
 		// local direction = uvw < 0 and uv or -uv
 		// return direction, a0, a1, b0, b1, c0, c1
-		if uv_w.is_negative(){
-			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
+		let dir=if uv_w.is_negative(){
+			narrow_dir2(uv)
 		}else{
-			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
-		}
+			narrow_dir2(-uv)
+		};
+		return Reduce::Reduced(Reduced{
+			dir,
+			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+		});
 	}
 
 	// local u_u = u:Dot(u)
@@ -439,22 +464,20 @@ fn reduce4<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
-			if uv_w.is_negative(){
-				return Reduce::Reduced(Reduced{
-					dir:uv.narrow_1().unwrap(),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
+			let dir=if uv_w.is_negative(){
+				narrow_dir2(uv)
 			}else{
-				return Reduce::Reduced(Reduced{
-					dir:-uv.narrow_1().unwrap(),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
-			}
+				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:direction.narrow_1().unwrap(),
+			dir:narrow_dir3(direction),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		});
 	}
@@ -464,17 +487,15 @@ fn reduce4<M:MeshQuery>(
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
-		if uv_w.is_negative(){
-			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
+		let dir=if uv_w.is_negative(){
+			narrow_dir2(uv)
 		}else{
-			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
-		}
+			narrow_dir2(-uv)
+		};
+		return Reduce::Reduced(Reduced{
+			dir,
+			simplex:Simplex1_3::Simplex1([v0]),
+		});
 	}
 
 	// return direction, a0, a1
@@ -504,24 +525,6 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
-	const ENABLE_FAST_FAIL:bool=true;
-	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
-		// on_exact
-		|is_intersecting,_simplex|{
-			is_intersecting
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			true
-		},
-		// fast_fail value
-		||false
-	)
-}
-
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition<Vert>{
@@ -737,11 +740,7 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 				Simplex1_3::Simplex2([v0,v1])=>{
 					// invert
 					let (v0,v1)=(-v0,-v1);
-					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
-					if !matches!(ev,EV::Edge(_)){
-						println!("I can't believe it's not an edge!");
-					}
-					ev.into()
+					crawl_to_closest_ev(mesh,[v0,v1],point).into()
 				},
 				Simplex1_3::Simplex3([v0,v1,v2])=>{
 					// invert
@@ -749,11 +748,7 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 					// Shimmy to the side until you find a face that contains the closest point
 					// it's ALWAYS representable as a face, but this algorithm may
 					// return E or V in edge cases but I don't think that will break the face crawler
-					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
-					if !matches!(fev,FEV::Face(_)){
-						println!("I can't believe it's not a face!");
-					}
-					fev
+					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
 				},
 			})
 		},
@@ -769,6 +764,24 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 	)
 }
 
+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,
@@ -870,6 +883,13 @@ mod test{
 	fn test_cube_points(){
 		let mesh=PhysicsMesh::unit_cube();
 		let mesh_view=mesh.complete_mesh_view();
-		assert!(mesh_contains_point(mesh_view,vec3::NEG_Z));
+		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

@@ -103,17 +103,21 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
+	// I didn't write it down, but I assume the edges are directed
+	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
+	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//bottom, top
+	verts:[SubmeshVertId;2],//start, end
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
+	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -593,7 +597,7 @@ impl core::ops::Neg for MinkowskiVert{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -608,7 +612,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -667,13 +671,24 @@ impl MinkowskiMesh<'_>{
 		}
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		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,
+		};
+		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()
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// 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;

engine/physics/src/physics.rs

@@ -28,6 +28,7 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
+	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -261,6 +262,15 @@ pub struct PhysicsCamera{
 impl PhysicsCamera{
 	const ANGLE_PITCH_LOWER_LIMIT:Angle32=Angle32::NEG_FRAC_PI_2;
 	const ANGLE_PITCH_UPPER_LIMIT:Angle32=Angle32::FRAC_PI_2;
+	pub fn new(
+		sensitivity:Ratio64Vec2,
+		clamped_mouse_pos:glam::IVec2,
+	)->Self{
+		Self{
+			sensitivity,
+			clamped_mouse_pos,
+		}
+	}
 	pub fn move_mouse(&mut self,mouse_delta:glam::IVec2){
 		let mut unclamped_mouse_pos=self.clamped_mouse_pos+mouse_delta;
 		unclamped_mouse_pos.y=unclamped_mouse_pos.y.clamp(
@@ -873,7 +883,7 @@ pub struct PhysicsState{
 	//input_state
 	input_state:InputState,
 	//style
-	style:StyleModifiers,//mode style with custom style updates applied
+	pub style:StyleModifiers,//mode style with custom style updates applied
 	//gameplay_state
 	mode_state:ModeState,
 	move_state:MoveState,
@@ -1669,7 +1679,20 @@ fn collision_start_intersect(
 			},
 			Some(gameplay_modes::Zone::Finish)=>{
 				match run.finish(time){
-					Ok(())=>println!("@@@@ Finished run time={}",run.time(time)),
+					Ok(())=>{
+						let time=run.time(time);
+						let h=time.get()/(Time::ONE_SECOND.get()*60*60);
+						let m=(time.get()/(Time::ONE_SECOND.get()*60)).rem_euclid(60);
+						let s=(time.get()/(Time::ONE_SECOND.get())).rem_euclid(60);
+						let ms=(time.get()/(Time::ONE_MILLISECOND.get())).rem_euclid(1000);
+						let us=(time.get()/(Time::ONE_MICROSECOND.get())).rem_euclid(1000);
+						let ns=(time.get()/(Time::ONE_NANOSECOND.get())).rem_euclid(1000);
+						if h==0{
+							println!("@@@@ Finished run time={m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
+						}else{
+							println!("@@@@ Finished run time={h}:{m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
+						}
+					},
 					Err(e)=>println!("@@@@ Run Finish error:{e:?}"),
 				}
 			},
@@ -1743,17 +1766,14 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	let (should_advance_body,goober_time)=match ins.instruction{
+	match ins.instruction{
+		// collisions advance the body precisely
 		InternalInstruction::CollisionStart(_,dt)
-		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
-		InternalInstruction::StrafeTick
-		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
-	};
-	if should_advance_body{
-		match goober_time{
-			Some(dt)=>state.body.advance_time_ratio_dt(dt),
-			None=>state.body.advance_time(state.time),
-		}
+		|InternalInstruction::CollisionEnd(_,dt)=>state.body.advance_time_ratio_dt(dt),
+		// this advances imprecisely
+		InternalInstruction::ReachWalkTargetVelocity=>state.body.advance_time(state.time),
+		// strafe tick decides for itself whether to advance the body.
+		InternalInstruction::StrafeTick=>(),
 	}
 		match ins.instruction{
 			InternalInstruction::CollisionStart(collision,_)=>{
@@ -1800,6 +1820,8 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						let masked_controls=strafe_settings.mask(controls);
 						let control_dir=state.style.get_control_dir(masked_controls);
 						if control_dir!=vec3::zero(){
+							// manually advance time
+							state.body.advance_time(state.time);
 							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
 							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
@@ -1972,7 +1994,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,..);
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -1990,7 +2012,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,..);
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){

engine/session/src/session.rs

@@ -52,7 +52,6 @@ pub enum SessionControlInstruction{
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
-	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
@@ -150,7 +149,7 @@ enum ViewState{
 }
 
 pub struct Session{
-	directories:Directories,
+	directories:Option<Directories>,
 	user_settings:UserSettings,
 	mouse_interpolator:MouseInterpolator,
 	view_state:ViewState,
@@ -165,7 +164,7 @@ pub struct Session{
 impl Session{
 	pub fn new(
 		user_settings:UserSettings,
-		directories:Directories,
+		directories:Option<Directories>,
 		simulation:Simulation,
 	)->Self{
 		Self{
@@ -253,7 +252,14 @@ 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
-				_=self.simulation.timer.set_paused(ins.time,paused);
+				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);
+					},
+				}
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -299,19 +305,21 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				match view_state{
 					ViewState::Play=>(),
 					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
-						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!");
-						});
+						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!");
+							});
+						}
 					},
 				}
 				_=self.simulation.timer.set_paused(ins.time,false);
@@ -374,14 +382,6 @@ 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/tests.rs

@@ -60,8 +60,12 @@ 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(-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(0,-429496729600,0),
 		Time::ZERO,
 	);

lib/fixed_wide/src/fixed.rs

@@ -366,7 +366,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 
 // This macro is not used in the default configuration.
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

lib/rbx_loader/Cargo.toml

@@ -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 }
-rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
 rbx_mesh = "0.5.0"
-rbx_reflection = "5.0.0"
-rbx_reflection_database = "1.0.0"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
+rbx_binary = "2.0.1"
+rbx_dom_weak = "4.1.0"
+rbx_reflection = "6.1.0"
+rbx_reflection_database = "2.0.2"
+rbx_xml = "2.0.1"
 
 [lints]
 workspace = true

lib/rbx_loader/src/rbx.rs

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

lib/roblox_emulator/Cargo.toml

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

lib/roblox_emulator/src/context.rs

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

lib/roblox_emulator/src/runner/enum.rs

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

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

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

map-tool/Cargo.toml

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

strafe-client/Cargo.toml

@@ -16,6 +16,7 @@ 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"
@@ -25,10 +26,14 @@ 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 }
-wgpu = "27.0.0"
+wasm-bindgen = "0.2.99"
+wasm-bindgen-futures = "0.4.49"
+web-sys = { version = "0.3.76", features = ["console"] }
+wgpu = "28.0.0"
 winit = "0.30.7"
 
 [profile.dev]

strafe-client/models/teslacyberv3.0.mtl

@@ -1,62 +0,0 @@
-# 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:std::time::Instant,
+	root_time:chrono::DateTime<chrono::Utc>,
 	window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>,
 }
 impl<'a> App<'a>{
 	pub fn new(
-		root_time:std::time::Instant,
+		root_time:chrono::DateTime<chrono::Utc>,
 		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(self.root_time.elapsed().as_nanos() as i64);
+		let time=integer::Time::from_nanos((chrono::Utc::now()-self.root_time).num_nanoseconds().unwrap());
 		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)+Send+'a>,
+	f:Box<dyn FnMut(Task)+'a>,
 }
 
 impl<'a,Task> CompatNWorker<'a,Task>{
-	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+'a)->CompatNWorker<'a,Task>{
 		Self{
 			f:Box::new(f),
 		}

strafe-client/src/file.rs

@@ -87,10 +87,13 @@ pub enum LoadFormat{
 	Bot(strafesnet_snf::bot::Segment),
 }
 
-pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
+pub fn load_file<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)?;
-	match read(file).map_err(LoadError::ReadError)?{
+	load(file)
+}
+pub fn load<R:Read+std::io::Seek>(reader:R)->Result<LoadFormat,LoadError>{
+	match read(reader).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,5 +9,8 @@ mod graphics_worker;
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 
 fn main(){
-	setup::setup_and_start(TITLE);
+	#[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));
 }

strafe-client/src/physics_worker.rs

@@ -1,13 +1,15 @@
 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,InstructionConsumer};
-use strafesnet_common::physics::Time as PhysicsTime;
-use strafesnet_common::session::Time as SessionTime;
-use strafesnet_common::timer::Timer;
+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;
 
 pub enum Instruction{
 	SessionInput(SessionInputInstruction),
@@ -19,12 +21,136 @@ 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:Directories,
+	directories:Option<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(
@@ -32,11 +158,20 @@ 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)=>{
-				session.process_instruction(TimedInstruction{
+				interpolator.handle_instruction(&TimedInstruction{
 					time:$time,
 					instruction:$instruction,
 				});
@@ -59,16 +194,17 @@ pub fn new<'a>(
 			},
 			Instruction::Render=>{
 				run_session_instruction!(ins.time,SessionInstruction::Idle);
-				if let Some(frame_state)=session.get_frame_state(ins.time){
+				if let Some(frame_state)=Some(interpolator.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=session.user_settings().clone();
+				let user_settings=interpolator.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,6 +20,16 @@ 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{
@@ -44,43 +54,20 @@ struct SetupContextPartial2<'a>{
 	surface:wgpu::Surface<'a>,
 }
 impl<'a> SetupContextPartial2<'a>{
-	fn pick_adapter(self)->SetupContextPartial3<'a>{
+	async 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();
 
-		//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!");
-		}
+		let chosen_adapter=self.instance.request_adapter(&wgpu::RequestAdapterOptions{
+			power_preference:wgpu::PowerPreference::HighPerformance,
+			force_fallback_adapter:false,
+			compatible_surface:Some(&self.surface),
+		}).await;
 
+		adapter=chosen_adapter.unwrap();
 
 		let adapter_info=adapter.get_info();
 		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
@@ -110,14 +97,15 @@ struct SetupContextPartial3<'a>{
 	adapter:wgpu::Adapter,
 }
 impl<'a> SetupContextPartial3<'a>{
-	fn request_device(self)->SetupContextPartial4<'a>{
+	async 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 (device, queue)=pollster::block_on(self.adapter
+		let trace_dir=std::env::var("WGPU_TRACE");
+		let (device, queue)=self.adapter
 			.request_device(
 				&wgpu::DeviceDescriptor{
 					label:None,
@@ -127,7 +115,7 @@ impl<'a> SetupContextPartial3<'a>{
 					trace:wgpu::Trace::Off,
 					experimental_features:wgpu::ExperimentalFeatures::disabled(),
 				},
-			))
+			).await
 			.expect("Unable to find a suitable GPU adapter!");
 
 		SetupContextPartial4{
@@ -169,7 +157,7 @@ pub struct SetupContext<'a>{
 	pub config:wgpu::SurfaceConfiguration,
 }
 
-pub fn setup_and_start(title:&str){
+pub async fn setup_and_start(title:&str){
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
 	println!("Initializing the surface...");
@@ -180,9 +168,9 @@ pub fn setup_and_start(title:&str){
 
 	let partial_2=partial_1.create_surface(&window).unwrap();
 
-	let partial_3=partial_2.pick_adapter();
+	let partial_3=partial_2.pick_adapter().await;
 
-	let partial_4=partial_3.request_device();
+	let partial_4=partial_3.request_device().await;
 
 	let size=window.inner_size();
 
@@ -196,16 +184,16 @@ pub 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(arg.into())),
+			instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile("".into())),
 		}).unwrap();
-	};
+	//};
 
 	println!("Entering event loop...");
 	let mut app=crate::app::App::new(
-		std::time::Instant::now(),
+		chrono::Utc::now(),
 		window_thread
 	);
 	event_loop.run_app(&mut app).unwrap();

strafe-client/src/window.rs

@@ -15,6 +15,7 @@ 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>>,
@@ -24,16 +25,50 @@ 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)=>{
-				match crate::file::load(path.as_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)){
 					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,
@@ -46,35 +81,8 @@ impl WindowContext<'_>{
 				..
 			}=>{
 				match (logical_key,state){
-					(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::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::F11),winit::event::ElementState::Pressed)=>{
 						if self.window.fullscreen().is_some(){
 							self.window.set_fullscreen(None);
@@ -132,7 +140,16 @@ 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)=>session_playback!(TogglePaused,s),
+							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::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),
@@ -220,17 +237,21 @@ 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().unwrap();
+	let directories=Directories::user();
 	#[cfg(not(feature="user-install"))]
-	let directories=Directories::portable().unwrap();
+	let directories=Directories::portable().ok();
 
-	let user_settings=directories.settings();
+	let user_settings=match &directories{
+		Some(directories)=>directories.settings(),
+		None=>strafesnet_settings::settings::UserSettings::default(),
+	};
 
 	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
 	graphics.load_user_settings(&user_settings);
@@ -241,6 +262,7 @@ 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

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

web-client/Trunk.toml

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

web-client/index.html

@@ -0,0 +1,47 @@
+<!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>