Print Only Horizontal Velocity

The Speed function is unnecessary I forgot to remove it

src/graphics.rs

@@ -221,7 +221,7 @@ impl GraphicsState{
 		for model in indexed_models.models.into_iter(){
 			//convert ModelInstance into GraphicsModelInstance
 			let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
-				if instance.color.w==0.0{
+				if instance.color.w==0.0&&!model.groups.iter().any(|g|g.texture.is_some()){
 					None
 				}else{
 					Some(GraphicsModelInstance{

src/load_bsp.rs

@@ -16,12 +16,6 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
 		Ok(bsp)=>{
 			let mut spawn_point=integer::Planar64Vec3::ZERO;
 
-			let vertices: Vec<_> = bsp
-				.vertices
-				.iter()
-				.map(|vertex|<[f32;3]>::from(vertex.position))
-				.collect();
-
 			let mut name_from_texture_id=Vec::new();
 			let mut texture_id_from_name=std::collections::HashMap::new();
 
@@ -54,10 +48,11 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
 					let normal=face.normal();
 					let normal_idx=spam_normal.len() as u32;
 					spam_normal.push(valve_transform(<[f32;3]>::from(normal)));
-					let mut vertices:Vec<u32>=face.vertex_indexes().map(|vertex_index|{
-						let pos=glam::Vec3A::from_array(vertices[vertex_index as usize]);
+					let mut vertices:Vec<u32>=face.vertex_positions().map(|vertex_pos|{
+						let vertex_xyz=<[f32;3]>::from(vertex_pos);
+						let pos=glam::Vec3A::from_array(vertex_xyz);
 						let pos_idx=spam_pos.len();
-						spam_pos.push(valve_transform(vertices[vertex_index as usize]));
+						spam_pos.push(valve_transform(vertex_xyz));
 
 						//calculate texture coordinates
 						let tex=(glam::vec2(pos.dot(texture_u),pos.dot(texture_v))+texture_offset)/texture_size;

src/physics_worker.rs

@@ -1,133 +1,165 @@
-use crate::physics::{MouseState,PhysicsInputInstruction};
-use strafesnet_common::integer::Time;
-use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
-#[derive(Debug)]
-pub enum InputInstruction {
-	MoveMouse(glam::IVec2),
-	MoveRight(bool),
-	MoveUp(bool),
-	MoveBack(bool),
-	MoveLeft(bool),
-	MoveDown(bool),
-	MoveForward(bool),
-	Jump(bool),
-	Zoom(bool),
-	Reset,
-}
-pub enum Instruction{
-	Input(InputInstruction),
-	Render,
-	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
-	GenerateModels(crate::model::IndexedModelInstances),
-	ClearModels,
-	//Graphics(crate::graphics_worker::Instruction),
-}
-
-	pub fn new(mut physics:crate::physics::PhysicsState,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.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.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),
-				},
-				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,
-				});
-				
-				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.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.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
-				true
-			}{
-				//empty queue
-				while let Some(instruction)=timeline.pop_front(){
-					physics.run(instruction.time);
-					physics.process_instruction(TimedInstruction{
-						time:instruction.time,
-						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
-					});
-				}
-			}
-			match ins.instruction{
-				Instruction::Render=>{
-					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
-				},
-				Instruction::Resize(size,user_settings)=>{
-					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
-				},
-				Instruction::GenerateModels(indexed_model_instances)=>{
-					physics.generate_models(&indexed_model_instances);
-					physics.spawn(indexed_model_instances.spawn_point);
-					graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
-				},
-				Instruction::ClearModels=>{
-					physics.clear();
-					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
-				},
-				_=>(),
-			}
-		})
+use crate::physics::{MouseState,PhysicsInputInstruction};
+use strafesnet_common::integer::Time;
+use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
+use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
+
+#[derive(Debug)]
+pub enum InputInstruction {
+	MoveMouse(glam::IVec2),
+	MoveRight(bool),
+	MoveUp(bool),
+	MoveBack(bool),
+	MoveLeft(bool),
+	MoveDown(bool),
+	MoveForward(bool),
+	Jump(bool),
+	Zoom(bool),
+	Reset,
+}
+pub enum Instruction{
+	Input(InputInstruction),
+	Render,
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
+	GenerateModels(crate::model::IndexedModelInstances),
+	ClearModels,
+	//Graphics(crate::graphics_worker::Instruction),
+}
+
+pub struct Speed{
+	pub player_vel:Planar64Vec3,
+	pub time:Time
+}
+
+impl std::ops::Neg for Speed{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		Self{
+			player_vel:self.player_vel,
+			time:self.time
+		}
+	}
+}
+
+impl  Speed{
+	pub fn new(player_vel:Planar64Vec3,time:Time)->Self{
+		Self{
+			player_vel,
+			time,
+		}
+	}
+}
+	pub fn new(mut physics:crate::physics::PhysicsState,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.next_mouse.time;
+		let mut timeline=std::collections::VecDeque::new();
+		let mut next_velocity_print=std::time::Instant::now();
+		let mut player_vel = physics.body.velocity.length();
+		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.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),
+				},
+				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,
+				});
+				
+				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.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.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
+				true
+			}{
+				//empty queue
+				while let Some(instruction)=timeline.pop_front(){
+					physics.run(instruction.time);
+					physics.process_instruction(TimedInstruction{
+						time:instruction.time,
+						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
+					});
+				}
+				//some random print stuff
+				if 3.0/5.0<next_velocity_print.elapsed().as_secs_f64(){
+					next_velocity_print=next_velocity_print+std::time::Duration::from_secs_f64(1.0/30.0);
+					println!("velocity: {} u/s", (Planar64Vec3::new(physics.body.velocity.x(), Planar64::int(0), physics.body.velocity.z())).length()*(Planar64::int(130)/9));
+				}
+			}
+			match ins.instruction{
+				Instruction::Render=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
+				},
+				Instruction::Resize(size,user_settings)=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
+				},
+				Instruction::GenerateModels(indexed_model_instances)=>{
+					physics.generate_models(&indexed_model_instances);
+					physics.spawn(indexed_model_instances.spawn_point);
+					graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
+				},
+				Instruction::ClearModels=>{
+					physics.clear();
+					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
+				},
+				_=>(),
+			}
+		})
 	}