diff --git a/src/physics_worker.rs b/src/physics_worker.rs
index 1f0e970f..78a12508 100644
--- a/src/physics_worker.rs
+++ b/src/physics_worker.rs
@@ -23,109 +23,141 @@ pub enum Instruction{
ClearModels,
//Graphics(crate::graphics_worker::Instruction),
}
-
- 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 mouse_blocking=true;
- let mut last_mouse_time=physics.get_next_mouse().time;
- let mut timeline=std::collections::VecDeque::new();
- crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
- if if let Some(phys_input)=match &ins.instruction{
- Instruction::Input(input_instruction)=>match input_instruction{
- &InputInstruction::MoveMouse(m)=>{
- if mouse_blocking{
- //tell the game state which is living in the past about its future
- timeline.push_front(TimedInstruction{
- time: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{
- time:last_mouse_time,
- instruction:PhysicsInputInstruction::ReplaceMouse(
- MouseState{time: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;
- }
- last_mouse_time=ins.time;
- None
- },
- &InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
- &InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
- &InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
- &InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
- &InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
- &InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
- &InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
- &InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
- InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
- InputInstruction::PracticeFly=>Some(PhysicsInputInstruction::PracticeFly),
+pub struct MouseInterpolator{
+ timeline:std::collections::VecDeque<TimedInstruction<PhysicsInputInstruction>>,
+ last_mouse_time:Time,
+ mouse_blocking:bool,
+}
+impl MouseInterpolator{
+ fn push_mouse_instruction(&mut self,physics:&crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>,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: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:physics.get_next_mouse().pos},
+ MouseState{time:ins.time,pos:m}
+ ),
+ });
+ //delay physics execution until we have an interpolation target
+ self.mouse_blocking=true;
+ }
+ 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
},
- Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
- Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
- Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
- Instruction::Render=>Some(PhysicsInputInstruction::Idle),
- }{
- //non-mouse event
- timeline.push_back(TimedInstruction{
- time:ins.time,
- instruction:phys_input,
+ &InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
+ &InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
+ &InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
+ &InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
+ &InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
+ &InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
+ &InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
+ &InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
+ InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
+ InputInstruction::PracticeFly=>Some(PhysicsInputInstruction::PracticeFly),
+ },
+ Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
+ Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
+ Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
+ Instruction::Render=>Some(PhysicsInputInstruction::Idle),
+ }
+ }
+ fn update_mouse_blocking(&mut self,physics:&crate::physics::PhysicsContext,ins:&TimedInstruction<Instruction>)->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 Time::from_millis(10)<ins.time-physics.get_next_mouse().time{
+ //push an event to extrapolate no movement from
+ self.timeline.push_front(TimedInstruction{
+ time:self.last_mouse_time,
+ instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.get_next_mouse().pos}),
});
-
- 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{
- time:last_mouse_time,
- instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.get_next_mouse().pos}),
- });
- 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;
- 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
- last_mouse_time=ins.time;
- true
- }
- }else{
- //mouse event
+ 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.
+ self.mouse_blocking=false;
true
- }{
- //empty queue
- while let Some(instruction)=timeline.pop_front(){
- physics.run_input_instruction(instruction);
- }
+ }else{
+ false
}
- match ins.instruction{
- Instruction::Render=>{
- graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.get_next_mouse().pos)).unwrap();
- },
- Instruction::Resize(size,user_settings)=>{
- graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
- },
- Instruction::GenerateModels(map)=>{
- physics.generate_models(&map);
- physics.spawn();
- graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(map)).unwrap();
- },
- Instruction::ClearModels=>{
- physics.clear();
- graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
- },
- _=>(),
- }
- })
- }
\ No newline at end of file
+ }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=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
+ }
+ }
+ 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();
+ },
+ Instruction::Resize(size,user_settings)=>{
+ graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
+ },
+ Instruction::GenerateModels(map)=>{
+ physics.generate_models(&map);
+ physics.spawn();
+ graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(map)).unwrap();
+ },
+ Instruction::ClearModels=>{
+ physics.clear();
+ graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
+ },
+ _=>(),
+ }
+ })
+}