porting mistake

these were supposed to be 3 voxels but were on the order of 3 units

engine/physics/src/minimum_difference.rs

@@ -17,6 +17,13 @@ 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]),
@@ -241,6 +248,7 @@ 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)
@@ -264,6 +272,7 @@ fn reduce3<M:MeshQuery>(
 		}else{
 			uv
 		};
+		println!("and we got here?? direction={direction:?}");
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
@@ -372,9 +381,11 @@ fn reduce4<M:MeshQuery>(
 	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(){
+	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{
 		// 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
@@ -402,6 +413,8 @@ fn reduce4<M:MeshQuery>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
+		}else{
+			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -414,6 +427,8 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}
 
@@ -430,15 +445,17 @@ 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
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}
 	}
 
 	// local u_u = u:Dot(u)
@@ -470,15 +487,17 @@ fn reduce4<M:MeshQuery>(
 		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)
+			if uv_w.is_negative(){
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
 			}else{
-				narrow_dir2(-uv)
-			};
-			return Reduce::Reduced(Reduced{
-				dir,
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			});
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(-uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
 		}
 
 		// return direction, a0, a1, b0, b1
@@ -493,15 +512,17 @@ fn reduce4<M:MeshQuery>(
 	// 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)
+		if uv_w.is_negative(){
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex1([v0]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
 	}
 
 	// return direction, a0, a1
@@ -531,6 +552,24 @@ 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>{
@@ -729,7 +768,6 @@ 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();
@@ -745,7 +783,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 is_intersecting={is_intersecting} simplex={simplex:?}");
+			println!("on_exact simplex={simplex:?}");
 			if is_intersecting{
 				return None;
 			}
@@ -756,7 +794,11 @@ fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)-
 				Simplex1_3::Simplex2([v0,v1])=>{
 					// invert
 					let (v0,v1)=(-v0,-v1);
-					crawl_to_closest_ev(mesh,[v0,v1],point).into()
+					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
+					if !matches!(ev,EV::Edge(_)){
+						println!("I can't believe it's not an edge!");
+					}
+					ev.into()
 				},
 				Simplex1_3::Simplex3([v0,v1,v2])=>{
 					// invert
@@ -764,7 +806,11 @@ 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
-					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
+					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
 				},
 			})
 		},
@@ -780,24 +826,6 @@ 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,
@@ -828,7 +856,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!("direction={direction}");
+		println!("arity={} direction={direction}",simplex_small.len());
 
 		// 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("/home/quat/strafesnet/strafe-project/Trey-MinimumDifference.lua").unwrap());
+	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("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)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -612,7 +612,7 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),

engine/session/src/session.rs

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

@@ -115,3 +115,48 @@ 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, features = ["unicode-perl"] }
+regex = { version = "1.11.3", default-features = false }
 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

@@ -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/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,35 +24,6 @@ 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)=>{
@@ -64,10 +34,6 @@ 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,
@@ -80,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);
@@ -139,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),
@@ -257,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,