comment about processed_time

Cargo.lock

@@ -1405,7 +1405,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strafe-client"
-version = "0.3.0"
+version = "0.2.0"
 dependencies = [
  "async-executor",
  "bytemuck",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.3.0"
+version = "0.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/framework.rs

@@ -1,10 +1,12 @@
 use std::future::Future;
 #[cfg(target_arch = "wasm32")]
 use std::str::FromStr;
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Instant;
 #[cfg(target_arch = "wasm32")]
 use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
 use winit::{
-	event::{self, WindowEvent, DeviceEvent},
+	event::{self, WindowEvent},
 	event_loop::{ControlFlow, EventLoop},
 };
 
@@ -52,7 +54,7 @@ pub trait Example: 'static + Sized {
 		queue: &wgpu::Queue,
 	);
 	fn update(&mut self, event: WindowEvent);
-	fn device_event(&mut self, event: DeviceEvent);
+	fn move_mouse(&mut self, delta: (f64,f64));
 	fn render(
 		&mut self,
 		view: &wgpu::TextureView,
@@ -348,10 +350,13 @@ fn start<E: Example>(
 				}
 			},
 			event::Event::DeviceEvent {
-				event,
+				event:
+					winit::event::DeviceEvent::MouseMotion {
+						delta,
+					},
 				..
 			} => {
-				example.device_event(event);
+				example.move_mouse(delta);
 			},
 			event::Event::RedrawRequested(_) => {
 

src/instruction.rs

@@ -1,11 +1,10 @@
-#[derive(Debug)]
 pub struct TimedInstruction<I> {
 	pub time: crate::body::TIME,
 	pub instruction: I,
 }
 
 pub trait InstructionEmitter<I> {
-	fn next_instruction(&self, time_limit:crate::body::TIME) -> Option<TimedInstruction<I>>;
+	fn next_instruction(&self, time:crate::body::TIME) -> Option<TimedInstruction<I>>;
 }
 pub trait InstructionConsumer<I> {
 	fn process_instruction(&mut self, instruction:TimedInstruction<I>);

src/main.rs

@@ -1,5 +1,4 @@
 use bytemuck::{Pod, Zeroable};
-use strafe_client::{instruction::{TimedInstruction, InstructionConsumer},body::{InputInstruction, PhysicsInstruction}};
 use std::{borrow::Cow, time::Instant};
 use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
 
@@ -33,9 +32,90 @@ struct ModelGraphics {
 	model_buf: wgpu::Buffer,
 }
 
+// Note: we use the Y=up coordinate space in this example.
+struct Camera {
+	screen_size: (u32, u32),
+	offset: glam::Vec3,
+	fov: f32,
+	yaw: f32,
+	pitch: f32,
+	controls: u32,
+}
+
+const CONTROL_MOVEFORWARD:u32 = 0b00000001;
+const CONTROL_MOVEBACK:u32 = 0b00000010;
+const CONTROL_MOVERIGHT:u32 = 0b00000100;
+const CONTROL_MOVELEFT:u32 = 0b00001000;
+const CONTROL_MOVEUP:u32 = 0b00010000;
+const CONTROL_MOVEDOWN:u32 = 0b00100000;
+const CONTROL_JUMP:u32 = 0b01000000;
+const CONTROL_ZOOM:u32 = 0b10000000;
+
+const FORWARD_DIR:glam::Vec3 = glam::Vec3::new(0.0,0.0,-1.0);
+const RIGHT_DIR:glam::Vec3 = glam::Vec3::new(1.0,0.0,0.0);
+const UP_DIR:glam::Vec3 = glam::Vec3::new(0.0,1.0,0.0);
+
+fn get_control_dir(controls: u32) -> glam::Vec3{
+	//don't get fancy just do it
+	let mut control_dir:glam::Vec3 = glam::Vec3::new(0.0,0.0,0.0);
+	if controls & CONTROL_MOVEFORWARD == CONTROL_MOVEFORWARD {
+		control_dir+=FORWARD_DIR;
+	}
+	if controls & CONTROL_MOVEBACK == CONTROL_MOVEBACK {
+		control_dir+=-FORWARD_DIR;
+	}
+	if controls & CONTROL_MOVELEFT == CONTROL_MOVELEFT {
+		control_dir+=-RIGHT_DIR;
+	}
+	if controls & CONTROL_MOVERIGHT == CONTROL_MOVERIGHT {
+		control_dir+=RIGHT_DIR;
+	}
+	if controls & CONTROL_MOVEUP == CONTROL_MOVEUP {
+		control_dir+=UP_DIR;
+	}
+	if controls & CONTROL_MOVEDOWN == CONTROL_MOVEDOWN {
+		control_dir+=-UP_DIR;
+	}
+	return control_dir
+}
+
+	#[inline]
+	fn perspective_rh(fov_y_slope: f32, aspect_ratio: f32, z_near: f32, z_far: f32) -> glam::Mat4 {
+		//glam_assert!(z_near > 0.0 && z_far > 0.0);
+		let r = z_far / (z_near - z_far);
+		glam::Mat4::from_cols(
+			glam::Vec4::new(1.0/(fov_y_slope * aspect_ratio), 0.0, 0.0, 0.0),
+			glam::Vec4::new(0.0, 1.0/fov_y_slope, 0.0, 0.0),
+			glam::Vec4::new(0.0, 0.0, r, -1.0),
+			glam::Vec4::new(0.0, 0.0, r * z_near, 0.0),
+		)
+	}
+
+impl Camera {
+	fn to_uniform_data(&self, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
+		let aspect = self.screen_size.0 as f32 / self.screen_size.1 as f32;
+		let fov = if self.controls&CONTROL_ZOOM==0 {
+			self.fov
+		}else{
+			self.fov/5.0
+		};
+		let proj = perspective_rh(fov, aspect, 0.5, 1000.0);
+		let proj_inv = proj.inverse();
+		let view = glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.yaw, self.pitch, 0f32);
+		let view_inv = view.inverse();
+
+		let mut raw = [0f32; 16 * 3 + 4];
+		raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
+		raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
+		raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
+		raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
+		raw
+	}
+}
+
 pub struct Skybox {
 	start_time: std::time::Instant,
-	screen_size: (u32, u32),
+	camera: Camera,
 	physics: strafe_client::body::PhysicsState,
 	sky_pipeline: wgpu::RenderPipeline,
 	entity_pipeline: wgpu::RenderPipeline,
@@ -92,7 +172,7 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
 					for &index in &[0, end_index - 1, end_index] {
 						let vert = poly.0[index];
 						if let Some(&i)=vertex_index.get(&vert){
-							indices.push(i);
+							indices.push(i as u16);
 						}else{
 							let i=vertices.len() as u16;
 							vertices.push(Vertex {
@@ -129,21 +209,6 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
 	}
 }
 
-
-fn to_uniform_data(camera: &strafe_client::body::Camera, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
-	let proj=camera.proj();
-	let proj_inv = proj.inverse();
-	let view=camera.view(pos);
-	let view_inv = view.inverse();
-
-	let mut raw = [0f32; 16 * 3 + 4];
-	raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
-	raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
-	raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
-	raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
-	raw
-}
-
 impl strafe_client::framework::Example for Skybox {
 	fn optional_features() -> wgpu::Features {
 		wgpu::Features::TEXTURE_COMPRESSION_ASTC
@@ -218,28 +283,34 @@ impl strafe_client::framework::Example for Skybox {
 			source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
 		});
 
+		let camera = Camera {
+			screen_size: (config.width, config.height),
+			offset: glam::Vec3::new(0.0,4.5,0.0),
+			fov: 1.0, //fov_slope = tan(fov_y/2)
+			pitch: 0.0,
+			yaw: 0.0,
+			controls:0,
+		};
 		let physics = strafe_client::body::PhysicsState {
-			body: strafe_client::body::Body::with_pva(glam::vec3(0.0,50.0,0.0),glam::vec3(0.0,0.0,0.0),glam::vec3(0.0,-100.0,0.0)),
+			body: strafe_client::body::Body::with_position(glam::Vec3::new(5.0,2.0,5.0)),
 			time: 0,
 			tick: 0,
 			strafe_tick_num: 100,//100t
 			strafe_tick_den: 1_000_000_000,
-			gravity: glam::vec3(0.0,-100.0,0.0),
-			friction: 1.2,
-			walk_accel: 90.0,
+			gravity: glam::Vec3::new(0.0,-100.0,0.0),
+			friction: 90.0,
 			mv: 2.7,
 			grounded: false,
+			jump_trying: false,
+			temp_control_dir: glam::Vec3::ZERO,
 			walkspeed: 18.0,
 			contacts: std::collections::HashSet::new(),
-			models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).collect(),
-			walk: strafe_client::body::WalkState::new(),
-			hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
-			camera: strafe_client::body::Camera::from_offset(glam::vec3(0.0,4.5-2.5,0.0),(config.width as f32)/(config.height as f32)),
-			mouse_interpolation: strafe_client::body::MouseInterpolationState::new(),
-			controls: 0,
+    		models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).collect(),
+    		walk_target_velocity: glam::Vec3::ZERO,
+    		hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
 		};
 
-		let camera_uniforms = to_uniform_data(&physics.camera,physics.body.extrapolated_position(0));
+		let camera_uniforms = camera.to_uniform_data(physics.body.extrapolated_position(0));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
 			contents: bytemuck::cast_slice(&camera_uniforms),
@@ -474,7 +545,7 @@ impl strafe_client::framework::Example for Skybox {
 
 		Skybox {
 			start_time: Instant::now(),
-			screen_size: (config.width,config.height),
+			camera,
 			physics,
 			sky_pipeline,
 			entity_pipeline,
@@ -489,69 +560,61 @@ impl strafe_client::framework::Example for Skybox {
 
 	#[allow(clippy::single_match)]
 	fn update(&mut self, event: winit::event::WindowEvent) {
-		//nothing atm
-	}
-
-	fn device_event(&mut self, event: winit::event::DeviceEvent) {
-		//there's no way this is the best way get a timestamp.
-		let time=self.start_time.elapsed().as_nanos() as i64;
 		match event {
-			winit::event::DeviceEvent::Key(winit::event::KeyboardInput {
-				state,
-				scancode: keycode,
+			winit::event::WindowEvent::KeyboardInput {
+				input:
+					winit::event::KeyboardInput {
+						state,
+						virtual_keycode: Some(keycode),
+						..
+					},
 				..
-			}) => {
-				let s=match state {
-					winit::event::ElementState::Pressed => true,
-					winit::event::ElementState::Released => false,
-				};
-				if let Some(input_instruction)=match keycode {
-					17 => Some(InputInstruction::MoveForward(s)),//W
-					30 => Some(InputInstruction::MoveLeft(s)),//A
-					31 => Some(InputInstruction::MoveBack(s)),//S
-					32 => Some(InputInstruction::MoveRight(s)),//D
-					18 => Some(InputInstruction::MoveUp(s)),//E
-					16 => Some(InputInstruction::MoveDown(s)),//Q
-					57 => Some(InputInstruction::Jump(s)),//Space
-					44 => Some(InputInstruction::Zoom(s)),//Z
-					19 => if s{Some(InputInstruction::Reset)}else{None},//R
-					_ => None,
-				}
-				{
-					self.physics.run(time);
-					self.physics.process_instruction(TimedInstruction{
-						time,
-						instruction:PhysicsInstruction::Input(input_instruction),
-					})
-				}
-			},
-			winit::event::DeviceEvent::MouseMotion {
-			    delta,//these (f64,f64) are integers on my machine
 			} => {
-				//do not step the physics because the mouse polling rate is higher than the physics can run.
-				//essentially the previous input will be overwritten until a true step runs
-				//which is fine because they run all the time.
-				self.physics.process_instruction(TimedInstruction{
-					time,
-					instruction:PhysicsInstruction::Input(InputInstruction::MoveMouse(glam::ivec2(delta.0 as i32,delta.1 as i32))),
-				})
-			},
-			winit::event::DeviceEvent::MouseWheel {
-			    delta,
-			} => {
-				println!("mousewheel{:?}",delta);
-				if true{//self.physics.use_scroll
-					self.physics.run(time);
-					self.physics.process_instruction(TimedInstruction{
-						time,
-						instruction:PhysicsInstruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
-					})
+				match (state,keycode) {
+					(k,winit::event::VirtualKeyCode::W) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEFORWARD,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEFORWARD,
+					}
+					(k,winit::event::VirtualKeyCode::A) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVELEFT,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVELEFT,
+					}
+					(k,winit::event::VirtualKeyCode::S) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEBACK,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEBACK,
+					}
+					(k,winit::event::VirtualKeyCode::D) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVERIGHT,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVERIGHT,
+					}
+					(k,winit::event::VirtualKeyCode::E) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEUP,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEUP,
+					}
+					(k,winit::event::VirtualKeyCode::Q) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEDOWN,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEDOWN,
+					}
+					(k,winit::event::VirtualKeyCode::Space) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_JUMP,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_JUMP,
+					}
+					(k,winit::event::VirtualKeyCode::Z) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_ZOOM,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_ZOOM,
+					}
+					_ => (),
 				}
 			}
-			_=>(),
+			_ => {}
 		}
 	}
 
+	fn move_mouse(&mut self, delta: (f64,f64)) {
+		self.camera.pitch=(self.camera.pitch as f64+delta.1/-2048.) as f32;
+		self.camera.yaw=(self.camera.yaw as f64+delta.0/-2048.) as f32;
+	}
+
 	fn resize(
 		&mut self,
 		config: &wgpu::SurfaceConfiguration,
@@ -559,8 +622,7 @@ impl strafe_client::framework::Example for Skybox {
 		_queue: &wgpu::Queue,
 	) {
 		self.depth_view = Self::create_depth_texture(config, device);
-		self.screen_size = (config.width, config.height);
-		self.physics.camera.set_fov_aspect(1.0,(config.width as f32)/(config.height as f32));
+		self.camera.screen_size = (config.width, config.height);
 	}
 
 	fn render(
@@ -570,15 +632,20 @@ impl strafe_client::framework::Example for Skybox {
 		queue: &wgpu::Queue,
 		_spawner: &strafe_client::framework::Spawner,
 	) {
+		let camera_mat=glam::Mat3::from_euler(glam::EulerRot::YXZ,self.camera.yaw,0f32,0f32);
+		let control_dir=camera_mat*get_control_dir(self.camera.controls&(CONTROL_MOVELEFT|CONTROL_MOVERIGHT|CONTROL_MOVEFORWARD|CONTROL_MOVEBACK)).normalize_or_zero();
+
 		let time=self.start_time.elapsed().as_nanos() as i64;
 
+		self.physics.temp_control_dir=control_dir;
+		self.physics.jump_trying=self.camera.controls&CONTROL_JUMP!=0;
 		self.physics.run(time);
 
 		let mut encoder =
 			device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 
 		// update rotation
-		let camera_uniforms = to_uniform_data(&self.physics.camera,self.physics.body.extrapolated_position(time));
+		let camera_uniforms = self.camera.to_uniform_data(self.physics.body.extrapolated_position(time));
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,