debug

Completely replace the janky closest fev crawl from infinity algorithm with a dedicated purpose-built algorithm.  Finding the closest point on a MinkowskiMesh is equivalent to finding the closest point between two meshes.

Reviewed-on: #25
Co-authored-by: Rhys Lloyd <krakow20@gmail.com>
Co-committed-by: Rhys Lloyd <krakow20@gmail.com>

engine/physics/src/minimum_difference.rs

@@ -17,13 +17,6 @@ enum Simplex1_3<Vert>{
 	Simplex3(Simplex<3,Vert>),
 }
 impl<Vert> Simplex1_3<Vert>{
-	fn len(&self)->usize{
-		match self{
-			Simplex1_3::Simplex1(_)=>1,
-			Simplex1_3::Simplex2(_)=>2,
-			Simplex1_3::Simplex3(_)=>3,
-		}
-	}
 	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
 		match self{
 			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
@@ -248,7 +241,6 @@ fn reduce3<M:MeshQuery>(
 	let p=-(p0+point);
 	let mut u=p1-p0;
 	let v=p2-p0;
-	println!("p={p} u={u} v={v}");
 
 	// local uv = u:Cross(v)
 	// local up = u:Cross(p)
@@ -272,7 +264,6 @@ fn reduce3<M:MeshQuery>(
 		}else{
 			uv
 		};
-		println!("and we got here?? direction={direction:?}");
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
@@ -381,11 +372,9 @@ fn reduce4<M:MeshQuery>(
 	let uv_p=uv.dot(p);
 
 	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
-	let a=!pv_w.div_sign(uv_w).is_negative();
-	let b=!up_w.div_sign(uv_w).is_negative();
-	let c=!uv_p.div_sign(uv_w).is_negative();
-	println!("a={a} b={b} c={c}");
-	if a&&b&&c{
+	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
@@ -413,8 +402,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
@@ -427,8 +414,6 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
-		}else{
-			v2=v3;
 		}
 	}
 
@@ -445,17 +430,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:narrow_dir2(uv),
-				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-			});
+		let dir=if uv_w.is_negative(){
+			narrow_dir2(uv)
 		}else{
-			return Reduce::Reduced(Reduced{
-				dir:narrow_dir2(-uv),
-				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)
@@ -487,17 +470,15 @@ 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:narrow_dir2(uv),
-					simplex:Simplex1_3::Simplex2([v0,v1]),
-				});
+			let dir=if uv_w.is_negative(){
+				narrow_dir2(uv)
 			}else{
-				return Reduce::Reduced(Reduced{
-					dir:narrow_dir2(-uv),
-					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
@@ -512,17 +493,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:narrow_dir2(uv),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
+		let dir=if uv_w.is_negative(){
+			narrow_dir2(uv)
 		}else{
-			return Reduce::Reduced(Reduced{
-				dir:narrow_dir2(-uv),
-				simplex:Simplex1_3::Simplex1([v0]),
-			});
-		}
+			narrow_dir2(-uv)
+		};
+		return Reduce::Reduced(Reduced{
+			dir,
+			simplex:Simplex1_3::Simplex1([v0]),
+		});
 	}
 
 	// return direction, a0, a1
@@ -552,24 +531,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>{
@@ -768,6 +729,7 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 		},
 	}
 }
+
 pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
 	println!("=== LUA ===");
 	let (hits,_details)=crate::minimum_difference_lua::minimum_difference_details(mesh,point).unwrap();
@@ -783,7 +745,7 @@ fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)-
 	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
 		// on_exact
 		|is_intersecting,simplex|{
-			println!("on_exact simplex={simplex:?}");
+			println!("on_exact is_intersecting={is_intersecting} simplex={simplex:?}");
 			if is_intersecting{
 				return None;
 			}
@@ -794,11 +756,7 @@ fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)-
 				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
@@ -806,11 +764,7 @@ fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)-
 					// 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)
 				},
 			})
 		},
@@ -826,6 +780,24 @@ fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)-
 	)
 }
 
+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,
@@ -856,7 +828,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
 	// for _ = 1, 100 do
 	loop{
-		println!("arity={} direction={direction}",simplex_small.len());
+		println!("direction={direction}");
 
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)

engine/physics/src/minimum_difference_lua.rs

@@ -163,7 +163,7 @@ struct Ctx{
 	f:Function,
 }
 fn init_lua()->LuaResult<Ctx>{
-	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("Trey-MinimumDifference.lua").unwrap());
+	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("/home/quat/strafesnet/strafe-project/Trey-MinimumDifference.lua").unwrap());
 	let lua=Lua::new();
 	lua.sandbox(true)?;
 	let lib_f=lua.load(SOURCE.as_str()).set_name("Trey-MinimumDifference").into_function()?;

engine/physics/src/model.rs

@@ -597,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),
@@ -612,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),

engine/session/src/session.rs

@@ -52,7 +52,6 @@ pub enum SessionControlInstruction{
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
-	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
@@ -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
@@ -374,14 +380,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/test_scenes.rs

@@ -115,48 +115,3 @@ fn bug_3(){
 	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }
-
-fn test_scene_cylinder()->PhysicsData{
-	let mut builder=TestSceneBuilder::new();
-	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
-	let mesh=builder.push_mesh(strafesnet_rbx_loader::primitives::unit_cylinder(cube_face_description));
-	// place one 5x5x5 cylinder.
-	// log cylinder
-	// transform=PhysicsMeshTransform { vertex: Planar64Affine3 { matrix3: Matrix { array: [[-0.00000469, 20.41880000, -0.00001730], [-3.71969533, -0.00000d38, -11.c3c43095], [-11.c3c41e7d, 0.00000000, 3.719690ac]] }, translation: Vector { array: [-908.de600000, 28f.e5240000, 24c.c4d80000] } }, normal: Matrix { array: [[-0.00002d857e4861a0, 147.71af629e398c1d05, -0.0000ead3c8730458], [-6f.147da83887600000, -0.0001ab1b4486f8fc, -23d.04a89b8def680000], [-23d.04aae32fa55a8280, 0.0000018177694d73, 6f.147e3a4136524bf8]] }, det: 2942.07be40fdd83c96df87d34320 }
-	// wedge part
-	// transform=PhysicsMeshTransform { vertex: Planar64Affine3 { matrix3: Matrix { array: [[-4.9ba5b000, 0.00000000, 0.00000000], [0.00000000, 3.85509c00, 0.00000000], [0.00000000, 0.00000000, -4.9ba5b000]] }, translation: Vector { array: [-781.30380000, 35b.dab40000, 11c.a4160000] } }, normal: Matrix { array: [[-10.3941970ff7400000, 0.0000000000000000, 0.0000000000000000], [0.0000000000000000, 15.3bcf8e5c59000000, 0.0000000000000000], [0.0000000000000000, 0.0000000000000000, -10.3941970ff7400000]] }, det: 4a.c2312159fcd9163c00000000 }
-	builder.push_mesh_instance(mesh,Planar64Affine3::new(
-		mat3::Matrix3::from_cols([vec3::raw_array([-0x4_9ba5b000, 0x0_00000000, 0x0_00000000]), vec3::raw_array([0x0_00000000, 0x3_85509c00, 0x0_00000000]), vec3::raw_array([0x0_00000000, 0x0_00000000, -0x4_9ba5b000])]),
-		vec3::raw_array([-0x781_30380000, 0x35b_dab40000, 0x11c_a4160000])
-	));
-	builder.build()
-}
-
-#[test]
-fn test_minimum_difference(){
-	let physics_data=test_scene_cylinder();
-	// log cylinder
-	// H p(-2329.436, 694.175, 587.190) v(0.000, -5.714, 0.000) a(0.000, -100.000, 0.000) t(56s+880000000ns)
-	// wedge part
-	// H p(-1920.041, 867.905, 284.639) v(0.000, -4.695, 0.000) a(0.000, -100.000, 0.000) t(119s+260000000ns)
-	let body=strafesnet_physics::physics::Body::new(
-		vec3::try_from_f32_array([-1920.041, 867.905, 284.639]).unwrap(),
-		vec3::try_from_f32_array([0.000, -4.695, 0.000]).unwrap(),
-		vec3::int(0,-100,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	physics.style_mut().gravity=vec3::zero();
-	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(3))
-		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
-	// touch side of part at 0,0,0
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
-	// touch top of part at 5,-5,0
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
-	assert!(phys_iter.next().is_none());
-	let body=physics.body();
-	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
-	assert_eq!(body.velocity,vec3::int(0,0,0));
-	assert_eq!(body.acceleration,vec3::int(0,0,0));
-	assert_eq!(body.time,Time::from_secs(2));
-}

lib/rbx_loader/Cargo.toml

@@ -12,7 +12,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false }
+regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
 rbx_mesh = "0.5.0"
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }

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/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,6 +25,35 @@ 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)=>{
@@ -34,6 +64,10 @@ impl WindowContext<'_>{
 				}
 			},
 			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 +80,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 +139,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),
@@ -241,6 +257,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,