pain

The operating system does not report the timestamp at which it checks that the mouse was not moving, so the mouse interpolation will necessarily be incorrect for up to 1 polling period.  The alternative is to guess / make up a timestamp, but I don't want to do this.

strafe-client/src/main.rs

@@ -4,6 +4,7 @@ mod setup;
 mod window;
 mod worker;
 mod physics;
+mod session;
 mod graphics;
 mod settings;
 mod push_solve;
@@ -13,6 +14,7 @@ mod model_physics;
 mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
+mod mouse_interpolator;
 
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 

strafe-client/src/mouse_interpolator.rs

@@ -0,0 +1,114 @@
+use strafesnet_common::mouse::MouseState;
+use strafesnet_common::physics::{Instruction as PhysicsInputInstruction,Time as PhysicsTime,TimeInner as PhysicsTimeInner};
+use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
+use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,TimedInstruction};
+
+type TimedPhysicsInstruction=TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>;
+type PhysicsTimedUnbufferedInstruction=TimedInstruction<UnbufferedInputInstruction,PhysicsTimeInner>;
+type DoubleTimedUnbufferedInstruction=TimedInstruction<PhysicsTimedUnbufferedInstruction,SessionTimeInner>;
+
+const MOUSE_TIMEOUT:SessionTime=SessionTime::from_millis(10);
+
+#[derive(Debug)]
+pub enum UnbufferedInputInstruction{
+	MoveMouse(glam::IVec2),
+	MoveRight(bool),
+	MoveUp(bool),
+	MoveBack(bool),
+	MoveLeft(bool),
+	MoveDown(bool),
+	MoveForward(bool),
+	Jump(bool),
+	Zoom(bool),
+	ResetAndRestart,
+	ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
+	PracticeFly,
+	Idle,
+}
+
+pub enum StepInstruction{
+	Other,
+	ReplaceMouse,
+}
+
+pub struct MouseInterpolator{
+	last_mouse_state:MouseState<SessionTimeInner>,
+	// double timestamped timeline?
+	physics_timeline:std::collections::VecDeque<TimedPhysicsInstruction>,
+}
+// Maybe MouseInterpolator manipulation is better expressed using impls
+// and called from Instruction trait impls in session
+impl InstructionConsumer<PhysicsTimedUnbufferedInstruction> for MouseInterpolator{
+	type TimeInner=SessionTimeInner;
+	fn process_instruction(&mut self,ins:DoubleTimedUnbufferedInstruction){
+		self.push_unbuffered_input(ins)
+	}
+}
+impl InstructionEmitter<StepInstruction> for MouseInterpolator{
+	type TimeInner=SessionTimeInner;
+	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::TimeInner>>{
+		self.buffered_instruction_with_timeout(time_limit)
+	}
+}
+impl MouseInterpolator{
+	pub fn new()->MouseInterpolator{
+		MouseInterpolator{
+			last_mouse_state:MouseState::default(),
+			physics_timeline:std::collections::VecDeque::new(),
+		}
+	}
+	pub fn push_unbuffered_input(&mut self,ins:DoubleTimedUnbufferedInstruction){
+		// new input
+		// if there is zero instruction buffered, it means the mouse is not moving
+	}
+	fn is_first_ready(&self)->bool{
+		// if the last instruction is a ReplaceMouse instruction
+		matches!(self.physics_timeline.back(),Some(TimedInstruction{
+			instruction:PhysicsInputInstruction::ReplaceMouse(_,_),
+			..
+		}))
+		// or if the last instruction is a SetNextMouse instruction
+		// and there is 2 or more instructions
+		||1<self.physics_timeline.len()&&matches!(self.physics_timeline.back(),Some(TimedInstruction{
+			instruction:PhysicsInputInstruction::SetNextMouse(_),
+			..
+		}))
+	}
+	pub fn buffered_instruction_with_timeout(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,SessionTimeInner>>{
+		let timeout=self.last_mouse_state.time+MOUSE_TIMEOUT;
+		if timeout<time_limit{
+			// if the mouse has stopped moving for over 10ms, emit DoStepReplaceMouse at that exact timestamp
+			Some(TimedInstruction{
+				time:timeout,
+				instruction:StepInstruction::ReplaceMouse,
+			})
+		}else if self.is_first_ready(){
+			// emit Step
+			Some(TimedInstruction{
+				// this timestamp should not matter
+				// verify this and potentially emit a different type using the enum only
+				time:time_limit,
+				instruction:StepInstruction::Other,
+			})
+		}else{
+			None
+		}
+	}
+	pub fn pop_buffered_instruction(&mut self,ins:StepInstruction)->Option<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>{
+		match ins{
+			StepInstruction::Other=>{
+				// if the last instruction is a mouse instruction,
+				// then the buffer is in the process of flushing.
+				// pop and return the first event.
+				// if the first instruction is a mouse instruction,
+				// then events are being buffered to wait for another
+				// mouse instruction as an interpolation target
+			},
+			StepInstruction::ReplaceMouse=>{
+				// use the first instruction which should be a mouse instruction
+				// to push a ReplaceMouse instruction
+			},
+		}
+		None
+	}
+}

strafe-client/src/physics_worker.rs

@@ -1,249 +1,39 @@
-use strafesnet_common::mouse::MouseState;
+use crate::graphics_worker::Instruction as GraphicsInstruction;
+use crate::session::{Instruction as SessionInstruction,Session, Simulation};
+use strafesnet_common::physics::Time as PhysicsTime;
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
-use strafesnet_common::physics::{Time as PhysicsTime,TimeInner as PhysicsTimeInner,Instruction as PhysicsInputInstruction};
+use strafesnet_common::timer::Timer;
-use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::timer::{Scaled,Timer,TimerState};
-use mouse_interpolator::MouseInterpolator;
 
-
+type TimedSessionInstruction=strafesnet_common::instruction::TimedInstruction<SessionInstruction,SessionTimeInner>;
-pub struct FrameState{
-	pub body:crate::physics::Body,
-	pub camera:crate::physics::PhysicsCamera,
-	pub time:PhysicsTime,
-}
-
-#[derive(Debug)]
-pub enum InputInstruction{
-	MoveMouse(glam::IVec2),
-	MoveRight(bool),
-	MoveUp(bool),
-	MoveBack(bool),
-	MoveLeft(bool),
-	MoveDown(bool),
-	MoveForward(bool),
-	Jump(bool),
-	Zoom(bool),
-	ResetAndRestart,
-	ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
-	PracticeFly,
-}
-pub enum Instruction{
-	Input(InputInstruction),
-	Render,
-	Resize(winit::dpi::PhysicalSize<u32>),
-	ChangeMap(strafesnet_common::map::CompleteMap),
-	//SetPaused is not an InputInstruction: the physics doesn't know that it's paused.
-	SetPaused(bool),
-	//Graphics(crate::graphics_worker::Instruction),
-}
-mod mouse_interpolator{
-	use super::*;
-	//TODO: move this or tab
-pub struct MouseInterpolator{
-	//"PlayerController"
-	user_settings:crate::settings::UserSettings,
-	//"MouseInterpolator"
-	timeline:std::collections::VecDeque<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
-	last_mouse_time:PhysicsTime,
-	mouse_blocking:bool,
-	//"Simulation"
-	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-	physics:crate::physics::PhysicsContext,
-
-}
-impl MouseInterpolator{
-	pub fn new(
-		physics:crate::physics::PhysicsContext,
-		user_settings:crate::settings::UserSettings,
-	)->MouseInterpolator{
-		MouseInterpolator{
-			mouse_blocking:true,
-			last_mouse_time:physics.get_next_mouse().time,
-			timeline:std::collections::VecDeque::new(),
-			timer:Timer::from_state(Scaled::identity(),false),
-			physics,
-			user_settings,
-		}
-	}
-	fn push_mouse_instruction(&mut self,ins:&TimedInstruction<Instruction,SessionTimeInner>,m:glam::IVec2){
-		if self.mouse_blocking{
-			//tell the game state which is living in the past about its future
-			self.timeline.push_front(TimedInstruction{
-				time:self.last_mouse_time,
-				instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(ins.time),pos:m}),
-			});
-		}else{
-			//mouse has just started moving again after being still for longer than 10ms.
-			//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
-			self.timeline.push_front(TimedInstruction{
-				time:self.last_mouse_time,
-				instruction:PhysicsInputInstruction::ReplaceMouse(
-					MouseState{time:self.last_mouse_time,pos:self.physics.get_next_mouse().pos},
-					MouseState{time:self.timer.time(ins.time),pos:m}
-				),
-			});
-			//delay physics execution until we have an interpolation target
-			self.mouse_blocking=true;
-		}
-		self.last_mouse_time=self.timer.time(ins.time);
-	}
-	fn push(&mut self,time:SessionTime,phys_input:PhysicsInputInstruction){
-		//This is always a non-mouse event
-		self.timeline.push_back(TimedInstruction{
-			time:self.timer.time(time),
-			instruction:phys_input,
-		});
-	}
-	/// returns should_empty_queue
-	/// may or may not mutate internal state XD!
-	fn map_instruction(&mut self,ins:&TimedInstruction<Instruction,SessionTimeInner>)->bool{
-		let mut update_mouse_blocking=true;
-		match &ins.instruction{
-			Instruction::Input(input_instruction)=>match input_instruction{
-				&InputInstruction::MoveMouse(m)=>{
-					if !self.timer.is_paused(){
-						self.push_mouse_instruction(ins,m);
-					}
-					update_mouse_blocking=false;
-				},
-				&InputInstruction::MoveForward(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveForward(s)),
-				&InputInstruction::MoveLeft(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveLeft(s)),
-				&InputInstruction::MoveBack(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveBack(s)),
-				&InputInstruction::MoveRight(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveRight(s)),
-				&InputInstruction::MoveUp(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveUp(s)),
-				&InputInstruction::MoveDown(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveDown(s)),
-				&InputInstruction::Jump(s)=>self.push(ins.time,PhysicsInputInstruction::SetJump(s)),
-				&InputInstruction::Zoom(s)=>self.push(ins.time,PhysicsInputInstruction::SetZoom(s)),
-				&InputInstruction::ResetAndSpawn(mode_id,stage_id)=>{
-					self.push(ins.time,PhysicsInputInstruction::Reset);
-					self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
-					self.push(ins.time,PhysicsInputInstruction::Spawn(mode_id,stage_id));
-				},
-				InputInstruction::ResetAndRestart=>{
-					self.push(ins.time,PhysicsInputInstruction::Reset);
-					self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
-					self.push(ins.time,PhysicsInputInstruction::Restart);
-				},
-				InputInstruction::PracticeFly=>self.push(ins.time,PhysicsInputInstruction::PracticeFly),
-			},
-			//do these really need to idle the physics?
-			//sending None dumps the instruction queue
-			Instruction::ChangeMap(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
-			Instruction::Resize(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
-			Instruction::Render=>self.push(ins.time,PhysicsInputInstruction::Idle),
-			&Instruction::SetPaused(paused)=>{
-				if let Err(e)=self.timer.set_paused(ins.time,paused){
-					println!("Cannot SetPaused: {e}");
-				}
-				self.push(ins.time,PhysicsInputInstruction::Idle);
-			},
-		}
-		if update_mouse_blocking{
-			//this returns the bool for us
-			self.update_mouse_blocking(ins.time)
-		}else{
-			//do flush that queue
-			true
-		}
-	}
-	/// must check if self.mouse_blocking==true before calling!
-	fn unblock_mouse(&mut self,time:SessionTime){
-		//push an event to extrapolate no movement from
-		self.timeline.push_front(TimedInstruction{
-			time:self.last_mouse_time,
-			instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(time),pos:self.physics.get_next_mouse().pos}),
-		});
-		self.last_mouse_time=self.timer.time(time);
-		//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
-		self.mouse_blocking=false;
-	}
-	fn update_mouse_blocking(&mut self,time:SessionTime)->bool{
-		if self.mouse_blocking{
-			//assume the mouse has stopped moving after 10ms.
-			//shitty mice are 125Hz which is 8ms so this should cover that.
-			//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
-			//so mouse events are probably not handled separately from drawing and fire right before it :(
-			if PhysicsTime::from_millis(10)<self.timer.time(time)-self.physics.get_next_mouse().time{
-				self.unblock_mouse(time);
-				true
-			}else{
-				false
-			}
-		}else{
-			//keep this up to date so that it can be used as a known-timestamp
-			//that the mouse was not moving when the mouse starts moving again
-			self.last_mouse_time=self.timer.time(time);
-			true
-		}
-	}
-	fn empty_queue(&mut self){
-		while let Some(instruction)=self.timeline.pop_front(){
-			self.physics.run_input_instruction(instruction);
-		}
-	}
-	pub fn handle_instruction(&mut self,ins:&TimedInstruction<Instruction,SessionTimeInner>){
-		let should_empty_queue=self.map_instruction(ins);
-		if should_empty_queue{
-			self.empty_queue();
-		}
-	}
-	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
-		FrameState{
-			body:self.physics.camera_body(),
-			camera:self.physics.camera(),
-			time:self.timer.time(time),
-		}
-	}
-	pub fn change_map(&mut self,time:SessionTime,map:&strafesnet_common::map::CompleteMap){
-		//dump any pending interpolation state
-		if self.mouse_blocking{
-			self.unblock_mouse(time);
-		}
-		self.empty_queue();
-
-		//doing it like this to avoid doing PhysicsInstruction::ChangeMap(Rc<CompleteMap>)
-		self.physics.generate_models(&map);
-
-		//use the standard input interface so the instructions are written out to bots
-		self.handle_instruction(&TimedInstruction{
-			time,
-			instruction:Instruction::Input(InputInstruction::ResetAndSpawn(
-				strafesnet_common::gameplay_modes::ModeId::MAIN,
-				strafesnet_common::gameplay_modes::StageId::FIRST,
-			)),
-		});
-	}
-	pub const fn user_settings(&self)->&crate::settings::UserSettings{
-		&self.user_settings
-	}
-}
-}
 
 pub fn new<'a>(
 	mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
 	user_settings:crate::settings::UserSettings,
-)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
+)->crate::compat_worker::QNWorker<'a,TimedSessionInstruction>{
 	let physics=crate::physics::PhysicsContext::default();
-	let mut interpolator=MouseInterpolator::new(
+	let timer=Timer::unpaused(SessionTime::ZERO,PhysicsTime::ZERO);
-		physics,
+	let simulation=Simulation::new(timer,physics);
-		user_settings
+	let mouse_interpolator=crate::mouse_interpolator::MouseInterpolator::new();
+	let mut session=Session::new(
+		user_settings,
+		simulation,
 	);
-	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
+	crate::compat_worker::QNWorker::new(move |ins:TimedSessionInstruction|{
-		interpolator.handle_instruction(&ins);
+		session.handle_instruction(&ins);
 		match ins.instruction{
-			Instruction::Render=>{
+			SessionInstruction::Render=>{
-				let frame_state=interpolator.get_frame_state(ins.time);
+				let frame_state=session.get_frame_state(ins.time);
-				graphics_worker.send(crate::graphics_worker::Instruction::Render(frame_state)).unwrap();
+				graphics_worker.send(GraphicsInstruction::Render(frame_state)).unwrap();
 			},
-			Instruction::Resize(size)=>{
+			SessionInstruction::Resize(size)=>{
-				graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,interpolator.user_settings().clone())).unwrap();
+				graphics_worker.send(GraphicsInstruction::Resize(size,session.user_settings().clone())).unwrap();
 			},
-			Instruction::ChangeMap(map)=>{
+			SessionInstruction::ChangeMap(map)=>{
-				interpolator.change_map(ins.time,&map);
+				session.change_map(ins.time,&map);
-				graphics_worker.send(crate::graphics_worker::Instruction::ChangeMap(map)).unwrap();
+				graphics_worker.send(GraphicsInstruction::ChangeMap(map)).unwrap();
 			},
-			Instruction::Input(_)=>(),
+			SessionInstruction::Input(_)=>(),
-			Instruction::SetPaused(_)=>(),
+			SessionInstruction::SetPaused(_)=>(),
 		}
 	})
 }

strafe-client/src/session.rs

@@ -0,0 +1,127 @@
+use strafesnet_common::instruction::{InstructionConsumer, InstructionEmitter, InstructionFeedback, TimedInstruction};
+// session represents the non-hardware state of the client.
+// Ideally it is a deterministic state which is atomically updated by instructions, same as the simulation state.
+use strafesnet_common::physics::{Instruction as PhysicsInputInstruction,TimeInner as PhysicsTimeInner,Time as PhysicsTime};
+use strafesnet_common::timer::{Scaled,Timer};
+use strafesnet_common::session::{TimeInner as SessionTimeInner,Time as SessionTime};
+
+use crate::mouse_interpolator::{MouseInterpolator,UnbufferedInputInstruction,StepInstruction};
+
+pub enum ExternalInstruction{
+	ToBuffer(UnbufferedInputInstruction),
+	SetPaused(bool),
+	Render,
+	Resize(winit::dpi::PhysicalSize<u32>),
+	ChangeMap(strafesnet_common::map::CompleteMap),
+	//Graphics(crate::graphics_worker::Instruction),
+}
+
+pub struct FrameState{
+	pub body:crate::physics::Body,
+	pub camera:crate::physics::PhysicsCamera,
+	pub time:PhysicsTime,
+}
+
+pub struct Simulation{
+	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
+	physics:crate::physics::PhysicsContext,
+}
+impl Simulation{
+	pub const fn new(
+		timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
+		physics:crate::physics::PhysicsContext,
+	)->Self{
+		Self{
+			timer,
+			physics,
+		}
+	}
+}
+
+pub struct Replay{
+	last_instruction_id:usize,
+	instructions:Vec<PhysicsInputInstruction>,
+	simulation:Simulation,
+}
+impl Replay{
+	pub const fn new(
+		instructions:Vec<PhysicsInputInstruction>,
+		simulation:Simulation,
+	)->Self{
+		Self{
+			last_instruction_id:0,
+			instructions,
+			simulation,
+		}
+	}
+}
+
+pub struct Session{
+	user_settings:crate::settings::UserSettings,
+	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
+	//gui:GuiState
+	simulation:Simulation,
+	replays:Vec<Replay>,
+}
+impl Session{
+	pub fn new(
+		user_settings:crate::settings::UserSettings,
+		simulation:Simulation,
+	)->Self{
+		Self{
+			user_settings,
+			mouse_interpolator:MouseInterpolator::new(),
+			simulation,
+			replays:Vec::new(),
+		}
+	}
+}
+
+// mouseinterpolator consumes RawInputInstruction
+// mouseinterpolator emits PhysicsInputInstruction
+// mouseinterpolator consumes DoStep to move on to the next emitted instruction
+// Session comsumes SessionInstruction -> forwards RawInputInstruction to mouseinterpolator
+// Session consumes DoStep -> forwards DoStep to mouseinterpolator
+// Session emits DoStep
+
+impl InstructionConsumer<ExternalInstruction> for Session{
+	type TimeInner=SessionTimeInner;
+	fn process_instruction(&mut self,ins:TimedInstruction<ExternalInstruction,Self::TimeInner>){
+		match ins.instruction{
+			// send it down to MouseInterpolator with two timestamps, SessionTime and PhysicsTime
+			ExternalInstruction::ToBuffer(instruction)=>self.mouse_interpolator.process_instruction(TimedInstruction{
+				time:ins.time,
+				instruction:TimedInstruction{
+					time:self.simulation.timer.time(ins.time),
+					instruction,
+				},
+			}),
+			ExternalInstruction::SetPaused(paused)=>{
+				// 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);
+			}
+			ExternalInstruction::Render=>(),
+			ExternalInstruction::Resize(physical_size)=>(),
+			ExternalInstruction::ChangeMap(complete_map)=>(),
+		};
+		// run all buffered instruction produced
+		self.process_exhaustive(ins.time);
+	}
+}
+impl InstructionConsumer<StepInstruction> for Session{
+	type TimeInner=SessionTimeInner;
+	fn process_instruction(&mut self,ins:TimedInstruction<StepInstruction,Self::TimeInner>){
+		// ins.time ignored???
+		if let Some(instruction)=self.mouse_interpolator.pop_buffered_instruction(ins.instruction){
+			self.simulation.physics.run_input_instruction(instruction);
+		}
+	}
+}
+impl InstructionEmitter<StepInstruction> for Session{
+	type TimeInner=SessionTimeInner;
+	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::TimeInner>>{
+		self.mouse_interpolator.next_instruction(time_limit)
+	}
+}

strafe-client/src/window.rs

@@ -1,5 +1,4 @@
 use crate::physics_worker::InputInstruction;
-use strafesnet_common::integer;
 use strafesnet_common::instruction::TimedInstruction;
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};