src/physics_worker.rs

@@ -23,35 +23,41 @@ pub enum Instruction{
 	ClearModels,
 	//Graphics(crate::graphics_worker::Instruction),
 }
-
+pub struct MouseInterpolator{
-	pub fn new(mut physics:crate::physics::PhysicsContext,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
+	timeline:std::collections::VecDeque<TimedInstruction<PhysicsInputInstruction>>,
-		let mut mouse_blocking=true;
+	last_mouse_time:Time,
-		let mut last_mouse_time=physics.get_next_mouse().time;
+	mouse_blocking:bool,
-		let mut timeline=std::collections::VecDeque::new();
+}
-		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+impl MouseInterpolator{
-			if if let Some(phys_input)=match &ins.instruction{
+	fn push_mouse_instruction(&mut self,physics:&crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>,m:glam::IVec2){
-				Instruction::Input(input_instruction)=>match input_instruction{
+		if self.mouse_blocking{
-					&InputInstruction::MoveMouse(m)=>{
-						if mouse_blocking{
 			//tell the game state which is living in the past about its future
-							timeline.push_front(TimedInstruction{
+			self.timeline.push_front(TimedInstruction{
-								time:last_mouse_time,
+				time:self.last_mouse_time,
 				instruction:PhysicsInputInstruction::SetNextMouse(MouseState{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
-							timeline.push_front(TimedInstruction{
+			self.timeline.push_front(TimedInstruction{
-								time:last_mouse_time,
+				time:self.last_mouse_time,
 				instruction:PhysicsInputInstruction::ReplaceMouse(
-									MouseState{time:last_mouse_time,pos:physics.get_next_mouse().pos},
+					MouseState{time:self.last_mouse_time,pos:physics.get_next_mouse().pos},
 					MouseState{time:ins.time,pos:m}
 				),
 			});
 			//delay physics execution until we have an interpolation target
-							mouse_blocking=true;
+			self.mouse_blocking=true;
 		}
-						last_mouse_time=ins.time;
+		self.last_mouse_time=ins.time;
+	}
+	/// returns the mapped physics input instruction
+	/// may or may not mutate internal state XD!
+	fn map_instruction(&mut self,physics:&crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>)->Option<PhysicsInputInstruction>{
+		match &ins.instruction{
+			Instruction::Input(input_instruction)=>match input_instruction{
+				&InputInstruction::MoveMouse(m)=>{
+					self.push_mouse_instruction(physics,ins,m);
 					None
 				},
 				&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
@@ -69,27 +75,23 @@ pub enum Instruction{
 			Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
 			Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
 			Instruction::Render=>Some(PhysicsInputInstruction::Idle),
-			}{
+		}
-				//non-mouse event
+	}
-				timeline.push_back(TimedInstruction{
+	fn update_mouse_blocking(&mut self,physics:&crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>)->bool{
-					time:ins.time,
+		if self.mouse_blocking{
-					instruction:phys_input,
-				});
-				
-				if 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 Time::from_millis(10)<ins.time-physics.get_next_mouse().time{
 				//push an event to extrapolate no movement from
-						timeline.push_front(TimedInstruction{
+				self.timeline.push_front(TimedInstruction{
-							time:last_mouse_time,
+					time:self.last_mouse_time,
 					instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.get_next_mouse().pos}),
 				});
-						last_mouse_time=ins.time;
+				self.last_mouse_time=ins.time;
 				//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
-						mouse_blocking=false;
+				self.mouse_blocking=false;
 				true
 			}else{
 				false
@@ -97,18 +99,48 @@ pub enum Instruction{
 		}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
-					last_mouse_time=ins.time;
+			self.last_mouse_time=ins.time;
 			true
 		}
+	}
+	/// returns whether or not to empty the instruction queue
+	fn handle_physics_input(&mut self,physics:&crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>,phys_input_option:Option<PhysicsInputInstruction>)->bool{
+		if let Some(phys_input)=phys_input_option{
+			//non-mouse event
+			self.timeline.push_back(TimedInstruction{
+				time:ins.time,
+				instruction:phys_input,
+			});
+
+			//this returns the bool for us
+			self.update_mouse_blocking(physics,ins)
 		}else{
 			//mouse event
 			true
-			}{
+		}
-				//empty queue
+	}
-				while let Some(instruction)=timeline.pop_front(){
+	fn empty_queue(&mut self,physics:&mut crate::physics::PhysicsContext){
+		while let Some(instruction)=self.timeline.pop_front(){
 			physics.run_input_instruction(instruction);
 		}
 	}
+	fn handle_instruction(&mut self,physics:&mut crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>){
+		let physics_input_option=self.map_instruction(physics,ins);
+		let should_empty_queue=self.handle_physics_input(physics,ins,physics_input_option);
+		if should_empty_queue{
+			self.empty_queue(physics);
+		}
+	}
+}
+
+pub fn new(mut physics:crate::physics::PhysicsContext,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
+	let mut interpolator=MouseInterpolator{
+		mouse_blocking:true,
+		last_mouse_time:physics.get_next_mouse().time,
+		timeline:std::collections::VecDeque::new(),
+	};
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+		interpolator.handle_instruction(&mut physics,&ins);
 		match ins.instruction{
 			Instruction::Render=>{
 				graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.get_next_mouse().pos)).unwrap();