From da3d0ca2546ccf3994f4148187239ff73271fe04 Mon Sep 17 00:00:00 2001 From: Quaternions Date: Tue, 19 Sep 2023 17:53:29 -0700 Subject: [PATCH] redo input --- src/body.rs | 350 ++++++++++++++++++++++++++++++++++------------- src/framework.rs | 13 +- src/main.rs | 273 +++++++++++++----------------------- 3 files changed, 356 insertions(+), 280 deletions(-) diff --git a/src/body.rs b/src/body.rs index 37c9d22..e0e7b40 100644 --- a/src/body.rs +++ b/src/body.rs @@ -4,11 +4,7 @@ use crate::{instruction::{InstructionEmitter, InstructionConsumer, TimedInstruct pub enum PhysicsInstruction { CollisionStart(RelativeCollision), CollisionEnd(RelativeCollision), - SetControlDir(glam::Vec3), StrafeTick, - Jump, - SetWalkTargetVelocity(glam::Vec3), - RefreshWalkTarget, ReachWalkTargetVelocity, // Water, // Spawn( @@ -16,8 +12,23 @@ pub enum PhysicsInstruction { // bool,//true = Trigger; false = teleport // bool,//true = Force // ) + //InputInstructions conditionally activate RefreshWalkTarget (by doing what SetWalkTargetVelocity used to do and then flagging it) + Input(InputInstruction), //temp - SetPosition(glam::Vec3), + SetSpawnPosition(glam::Vec3), +} +#[derive(Debug)] +pub enum InputInstruction { + MoveMouse(glam::IVec2), + MoveForward(bool), + MoveLeft(bool), + MoveBack(bool), + MoveRight(bool), + MoveUp(bool), + MoveDown(bool), + Jump(bool), + Zoom(bool), + Reset, } pub struct Body { @@ -53,34 +64,35 @@ pub enum MoveRestriction { Ladder,//multiple ladders how } -enum MouseInterpolation { - First,//just checks the last value - Lerp,//lerps between -} - +/* enum InputInstruction { - MoveMouse(glam::IVec2), - Jump(bool), } - struct InputState { - controls: u32, - mouse_interpolation: MouseInterpolation, - time: TIME, } - impl InputState { pub fn get_control(&self,control:u32) -> bool { self.controls&control!=0 } - pub fn process_instruction(&mut self,ins:InputInstruction){ - match ins { - InputInstruction::MoveMouse(m) => todo!("set mouse_interpolation"), - InputInstruction::Jump(b) => todo!("how does info about style modifiers get here"), - } +} +impl crate::instruction::InstructionEmitter for InputState{ + fn next_instruction(&self, time_limit:crate::body::TIME) -> Option> { + //this is polled by PhysicsState for actions like Jump + //no, it has to be the other way around. physics is run up until the jump instruction, and then the jump instruction is pushed. + self.queue.get(0) } } +impl crate::instruction::InstructionConsumer for InputState{ + fn process_instruction(&mut self,ins:TimedInstruction){ + //add to queue + self.queue.push(ins); + } +} +*/ +enum MouseInterpolation { + First,//just checks the last value + Lerp,//lerps between +} pub struct MouseInterpolationState { interpolation: MouseInterpolation, time0: TIME, @@ -90,11 +102,20 @@ pub struct MouseInterpolationState { } impl MouseInterpolationState { - pub fn move_mouse(&mut self,time:TIME,pos:glam::IVec2){ + pub fn new() -> Self { + Self { + interpolation:MouseInterpolation::First, + time0:0, + time1:1,//ONE NANOSECOND!!!! avoid divide by zero + mouse0:glam::IVec2::ZERO, + mouse1:glam::IVec2::ZERO, + } + } + pub fn move_mouse(&mut self,time:TIME,delta:glam::IVec2){ self.time0=self.time1; self.mouse0=self.mouse1; self.time1=time; - self.mouse1=pos; + self.mouse1=self.mouse1+delta; } pub fn interpolated_position(&self,time:TIME) -> glam::IVec2 { match self.interpolation { @@ -115,7 +136,6 @@ impl MouseInterpolationState { pub enum WalkEnum{ Reached, Transient, - Invalid, } pub struct WalkState { pub target_velocity: glam::Vec3, @@ -127,22 +147,120 @@ impl WalkState { Self{ target_velocity:glam::Vec3::ZERO, target_time:0, - state:WalkEnum::Invalid, + state:WalkEnum::Reached, } } } +// Note: we use the Y=up coordinate space in this example. +pub struct Camera { + offset: glam::Vec3, + angles: glam::DVec2,//YAW AND THEN PITCH + //punch: glam::Vec3, + //punch_velocity: glam::Vec3, + fov: glam::Vec2,//slope + sensitivity: glam::DVec2, + time: TIME, +} + +#[inline] +fn mat3_from_rotation_y_f64(angle: f64) -> glam::Mat3 { + let (sina, cosa) = angle.sin_cos(); + glam::Mat3::from_cols( + glam::Vec3::new(cosa as f32, 0.0, -sina as f32), + glam::Vec3::Y, + glam::Vec3::new(sina as f32, 0.0, cosa as f32), + ) +} +#[inline] +fn perspective_rh(fov_x_slope: f32, fov_y_slope: 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_x_slope, 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 { + pub fn from_offset(offset:glam::Vec3,aspect:f32) -> Self { + Self{ + offset, + angles: glam::DVec2::ZERO, + fov: glam::vec2(aspect,1.0), + sensitivity: glam::dvec2(1.0/2048.0,1.0/2048.0), + time: 0, + } + } + fn simulate_move_angles(&self, delta: glam::IVec2) -> glam::DVec2 { + let mut a=self.angles-self.sensitivity*delta.as_dvec2(); + a.y=a.y.clamp(-std::f64::consts::PI, std::f64::consts::PI); + return a + } + fn simulate_move_rotation_y(&self, delta_x: i32) -> glam::Mat3 { + mat3_from_rotation_y_f64(self.angles.x-self.sensitivity.x*(delta_x as f64)) + } + pub fn proj(&self)->glam::Mat4{ + perspective_rh(self.fov.x, self.fov.y, 0.5, 1000.0) + } + pub fn view(&self,pos:glam::Vec3)->glam::Mat4{ + //f32 good enough for view matrix + glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.angles.x as f32, self.angles.y as f32, 0f32) + } + pub fn set_fov_aspect(&mut self,fov:f32,aspect:f32){ + self.fov.x=fov*aspect; + self.fov.y=fov; + } +} + +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 +} + pub struct PhysicsState { pub body: Body, pub hitbox_halfsize: glam::Vec3, pub contacts: std::collections::HashSet::, //pub intersections: Vec, pub models: Vec, - //temp - pub temp_control_dir: glam::Vec3, //camera must exist in state because wormholes modify the camera, also camera punch - //pub camera: Camera, - //pub mouse_interpolation: MouseInterpolationState, + pub camera: Camera, + pub mouse_interpolation: MouseInterpolationState, + pub controls: u32, pub time: TIME, pub strafe_tick_num: TIME, pub strafe_tick_den: TIME, @@ -154,7 +272,7 @@ pub struct PhysicsState { pub walk_accel: f32, pub gravity: glam::Vec3, pub grounded: bool, - pub jump_trying: bool, + pub spawn_point: glam::Vec3, } #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)] @@ -355,8 +473,6 @@ impl PhysicsState { pub fn run(&mut self, time_limit:TIME){ //prepare is ommitted - everything is done via instructions. while let Some(instruction) = self.next_instruction(time_limit) {//collect - //advance - //self.advance_time(instruction.time); //process self.process_instruction(instruction); //write hash lol @@ -368,6 +484,16 @@ impl PhysicsState { self.time=time; } + fn set_control(&mut self,control:u32,state:bool){ + self.controls=if state{self.controls|control}else{self.controls&!control}; + } + fn jump(&mut self){ + self.grounded=false;//do I need this? + let mut v=self.body.velocity+glam::Vec3::new(0.0,0.715588/2.0*100.0,0.0); + self.contact_constrain_velocity(&mut v); + self.body.velocity=v; + } + fn contact_constrain_velocity(&self,velocity:&mut glam::Vec3){ for contact in self.contacts.iter() { let n=contact.normal(&self.models); @@ -386,7 +512,6 @@ impl PhysicsState { } } } - fn next_strafe_instruction(&self) -> Option> { return Some(TimedInstruction{ time:(self.time*self.strafe_tick_num/self.strafe_tick_den+1)*self.strafe_tick_den/self.strafe_tick_num, @@ -426,6 +551,31 @@ impl PhysicsState { // }); // } + fn refresh_walk_target(&mut self){ + //calculate acceleration yada yada + if self.grounded{ + let mut v=self.walk.target_velocity; + self.contact_constrain_velocity(&mut v); + let mut target_diff=v-self.body.velocity; + target_diff.y=0f32; + if target_diff==glam::Vec3::ZERO{ + let mut a=glam::Vec3::ZERO; + self.contact_constrain_acceleration(&mut a); + self.body.acceleration=a; + self.walk.state=WalkEnum::Reached; + }else{ + let accel=self.walk_accel.min(self.gravity.length()*self.friction); + let time_delta=target_diff.length()/accel; + let mut a=target_diff/time_delta; + self.contact_constrain_acceleration(&mut a); + self.body.acceleration=a; + self.walk.target_time=self.body.time+((time_delta as f64)*1_000_000_000f64) as TIME; + self.walk.state=WalkEnum::Transient; + } + }else{ + self.walk.state=WalkEnum::Reached;//there is no walk target while not grounded + } + } fn next_walk_instruction(&self) -> Option> { //check if you have a valid walk state and create an instruction if self.grounded{ @@ -434,10 +584,6 @@ impl PhysicsState { time:self.walk.target_time, instruction:PhysicsInstruction::ReachWalkTargetVelocity }), - WalkEnum::Invalid=>Some(TimedInstruction{ - time:self.time, - instruction:PhysicsInstruction::RefreshWalkTarget, - }), WalkEnum::Reached=>None, } }else{ @@ -753,29 +899,22 @@ impl crate::instruction::InstructionConsumer for PhysicsStat fn process_instruction(&mut self, ins:TimedInstruction) { match &ins.instruction { PhysicsInstruction::StrafeTick => (), + PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (), _=>println!("{:?}",ins), } //selectively update body match &ins.instruction { - PhysicsInstruction::SetWalkTargetVelocity(_) - |PhysicsInstruction::SetPosition(_) - |PhysicsInstruction::SetControlDir(_) => self.time=ins.time,//TODO: queue instructions - PhysicsInstruction::RefreshWalkTarget + PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (),//dodge time for mouse movement + PhysicsInstruction::Input(_) + |PhysicsInstruction::SetSpawnPosition(_) |PhysicsInstruction::ReachWalkTargetVelocity |PhysicsInstruction::CollisionStart(_) |PhysicsInstruction::CollisionEnd(_) - |PhysicsInstruction::StrafeTick - |PhysicsInstruction::Jump => self.advance_time(ins.time), + |PhysicsInstruction::StrafeTick => self.advance_time(ins.time), } match ins.instruction { - PhysicsInstruction::SetPosition(position)=>{ - //temp - self.body.position=position; - //manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))} - self.contacts.clear(); - self.body.acceleration=self.gravity; - self.walk.state=WalkEnum::Reached; - self.grounded=false; + PhysicsInstruction::SetSpawnPosition(position)=>{ + self.spawn_point=position; } PhysicsInstruction::CollisionStart(c) => { //check ground @@ -791,14 +930,16 @@ impl crate::instruction::InstructionConsumer for PhysicsStat let mut v=self.body.velocity; self.contact_constrain_velocity(&mut v); self.body.velocity=v; - self.walk.state=WalkEnum::Invalid; + if self.grounded&&self.controls&CONTROL_JUMP!=0{ + self.jump(); + } + self.refresh_walk_target(); }, PhysicsInstruction::CollisionEnd(c) => { self.contacts.remove(&c);//remove contact before calling contact_constrain_acceleration let mut a=self.gravity; self.contact_constrain_acceleration(&mut a); self.body.acceleration=a; - self.walk.state=WalkEnum::Invalid; //check ground match &c.face { AabbFace::Top => { @@ -806,27 +947,18 @@ impl crate::instruction::InstructionConsumer for PhysicsStat }, _ => (), } - }, - PhysicsInstruction::SetControlDir(control_dir)=>{ - self.temp_control_dir=control_dir; - self.walk.state=WalkEnum::Invalid; + self.refresh_walk_target(); }, PhysicsInstruction::StrafeTick => { - //let control_dir=self.get_control_dir();//this should respect your mouse interpolation settings - let d=self.body.velocity.dot(self.temp_control_dir); + let camera_mat=self.camera.simulate_move_rotation_y(self.mouse_interpolation.interpolated_position(self.time).x-self.mouse_interpolation.mouse0.x); + let control_dir=camera_mat*get_control_dir(self.controls); + let d=self.body.velocity.dot(control_dir); if d { - self.grounded=false;//do I need this? - let mut v=self.body.velocity+glam::Vec3::new(0.0,0.715588/2.0*100.0,0.0); - self.contact_constrain_velocity(&mut v); - self.body.velocity=v; - self.walk.state=WalkEnum::Invalid; - }, PhysicsInstruction::ReachWalkTargetVelocity => { //precisely set velocity let mut a=glam::Vec3::ZERO; @@ -837,32 +969,66 @@ impl crate::instruction::InstructionConsumer for PhysicsStat self.body.velocity=v; self.walk.state=WalkEnum::Reached; }, - PhysicsInstruction::RefreshWalkTarget => { - //calculate acceleration yada yada - if self.grounded{ - let mut v=self.walk.target_velocity; - self.contact_constrain_velocity(&mut v); - let mut target_diff=v-self.body.velocity; - target_diff.y=0f32; - if target_diff==glam::Vec3::ZERO{ - let mut a=glam::Vec3::ZERO; - self.contact_constrain_acceleration(&mut a); - self.body.acceleration=a; + PhysicsInstruction::Input(input_instruction) => { + let mut refresh_walk_target=false; + match input_instruction{ + InputInstruction::MoveMouse(m) => { + self.camera.angles=self.camera.simulate_move_angles(self.mouse_interpolation.mouse1-self.mouse_interpolation.mouse0); + self.mouse_interpolation.move_mouse(self.time,m); + refresh_walk_target=true; + }, + InputInstruction::MoveForward(s) => { + self.set_control(CONTROL_MOVEFORWARD,s); + refresh_walk_target=true; + }, + InputInstruction::MoveLeft(s) => { + self.set_control(CONTROL_MOVELEFT,s); + refresh_walk_target=true; + }, + InputInstruction::MoveBack(s) => { + self.set_control(CONTROL_MOVEBACK,s); + refresh_walk_target=true; + }, + InputInstruction::MoveRight(s) => { + self.set_control(CONTROL_MOVERIGHT,s); + refresh_walk_target=true; + }, + InputInstruction::MoveUp(s) => { + self.set_control(CONTROL_MOVEUP,s); + refresh_walk_target=true; + }, + InputInstruction::MoveDown(s) => { + self.set_control(CONTROL_MOVEDOWN,s); + refresh_walk_target=true; + }, + InputInstruction::Jump(s) => { + self.set_control(CONTROL_JUMP,s); + refresh_walk_target=true; + if self.grounded{ + self.jump(); + } + }, + InputInstruction::Zoom(s) => { + self.set_control(CONTROL_ZOOM,s); + }, + InputInstruction::Reset => { + //temp + self.body.position=self.spawn_point; + //manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))} + self.contacts.clear(); + self.body.acceleration=self.gravity; self.walk.state=WalkEnum::Reached; - }else{ - let accel=self.walk_accel.min(self.gravity.length()*self.friction); - let time_delta=target_diff.length()/accel; - let mut a=target_diff/time_delta; - self.contact_constrain_acceleration(&mut a); - self.body.acceleration=a; - self.walk.target_time=self.body.time+((time_delta as f64)*1_000_000_000f64) as TIME; - self.walk.state=WalkEnum::Transient; - } + self.grounded=false; + }, + } + //calculate control dir + let camera_mat=self.camera.simulate_move_rotation_y(self.mouse_interpolation.interpolated_position(self.time).x-self.mouse_interpolation.mouse0.x); + let control_dir=camera_mat*get_control_dir(self.controls); + //calculate walk target velocity + if refresh_walk_target{ + self.walk.target_velocity=self.walkspeed*control_dir; + self.refresh_walk_target(); } - }, - PhysicsInstruction::SetWalkTargetVelocity(v) => { - self.walk.target_velocity=v; - self.walk.state=WalkEnum::Invalid; }, } } diff --git a/src/framework.rs b/src/framework.rs index b471c22..03f1448 100644 --- a/src/framework.rs +++ b/src/framework.rs @@ -1,12 +1,10 @@ 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}, + event::{self, WindowEvent, DeviceEvent}, event_loop::{ControlFlow, EventLoop}, }; @@ -54,7 +52,7 @@ pub trait Example: 'static + Sized { queue: &wgpu::Queue, ); fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent); - fn move_mouse(&mut self, delta: (f64,f64)); + fn device_event(&mut self, event: DeviceEvent); fn render( &mut self, view: &wgpu::TextureView, @@ -373,13 +371,10 @@ fn start( } }, event::Event::DeviceEvent { - event: - winit::event::DeviceEvent::MouseMotion { - delta, - }, + event, .. } => { - example.move_mouse(delta); + example.device_event(event); }, event::Event::RedrawRequested(_) => { diff --git a/src/main.rs b/src/main.rs index 0c4ccda..ec2df75 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,8 @@ use std::{borrow::Cow, time::Instant}; use wgpu::{util::DeviceExt, AstcBlock, AstcChannel}; use model::{Vertex,ModelData,ModelInstance}; +use body::{InputInstruction, PhysicsInstruction}; +use instruction::{TimedInstruction, InstructionConsumer}; mod body; mod model; @@ -23,86 +25,6 @@ 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 GraphicsSamplers{ repeat: wgpu::Sampler, } @@ -123,7 +45,7 @@ pub struct GraphicsPipelines { pub struct GraphicsData { start_time: std::time::Instant, - camera: Camera, + screen_size: (u32, u32), physics: body::PhysicsState, pipelines: GraphicsPipelines, bind_groups: GraphicsBindGroups, @@ -300,6 +222,20 @@ fn get_instances_buffer_data(instances:&[ModelInstance]) -> Vec { raw } +fn to_uniform_data(camera: &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 framework::Example for GraphicsData { fn optional_features() -> wgpu::Features { wgpu::Features::TEXTURE_COMPRESSION_ASTC @@ -449,15 +385,8 @@ impl framework::Example for GraphicsData { 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-2.5,0.0), - fov: 1.0, //fov_slope = tan(fov_y/2) - pitch: 0.0, - yaw: 0.0, - controls:0, - }; let physics = body::PhysicsState { + spawn_point:glam::vec3(0.0,50.0,0.0), body: 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)), time: 0, tick: 0, @@ -468,13 +397,14 @@ impl framework::Example for GraphicsData { walk_accel: 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: Vec::new(), - walk: body::WalkState::new(), - hitbox_halfsize: glam::vec3(1.0,2.5,1.0), + models: Vec::new(), + walk: body::WalkState::new(), + hitbox_halfsize: glam::vec3(1.0,2.5,1.0), + camera: body::Camera::from_offset(glam::vec3(0.0,4.5-2.5,0.0),(config.width as f32)/(config.height as f32)), + mouse_interpolation: body::MouseInterpolationState::new(), + controls: 0, }; //load textures @@ -663,7 +593,7 @@ impl framework::Example for GraphicsData { multiview: None, }); - let camera_uniforms = camera.to_uniform_data(physics.body.extrapolated_position(0)); + let camera_uniforms = to_uniform_data(&physics.camera,physics.body.extrapolated_position(0)); let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some("Camera"), contents: bytemuck::cast_slice(&camera_uniforms), @@ -698,7 +628,7 @@ impl framework::Example for GraphicsData { let mut graphics=GraphicsData { start_time: Instant::now(), - camera, + screen_size: (config.width,config.height), physics, pipelines:GraphicsPipelines{ skybox:sky_pipeline, @@ -769,8 +699,12 @@ impl framework::Example for GraphicsData { let time=self.physics.time; instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{ time, - instruction: body::PhysicsInstruction::SetPosition(spawn_point), - }) + instruction: body::PhysicsInstruction::SetSpawnPosition(spawn_point), + }); + instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{ + time, + instruction: body::PhysicsInstruction::Input(body::InputInstruction::Reset), + }); }else{ println!("No modeldatas were generated"); } @@ -781,58 +715,68 @@ impl framework::Example for GraphicsData { println!("Could not open file"); } }, - winit::event::WindowEvent::KeyboardInput { - input: - winit::event::KeyboardInput { - state, - virtual_keycode: Some(keycode), - .. - }, - .. - } => { - 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 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, + .. + }) => { + 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 + }) + } + } + _=>(), + } } fn resize( @@ -842,7 +786,8 @@ impl framework::Example for GraphicsData { _queue: &wgpu::Queue, ) { self.depth_view = Self::create_depth_texture(config, device); - self.camera.screen_size = (config.width, config.height); + self.screen_size = (config.width, config.height); + self.physics.camera.set_fov_aspect(1.0,(config.width as f32)/(config.height as f32)); } fn render( @@ -852,45 +797,15 @@ impl framework::Example for GraphicsData { queue: &wgpu::Queue, _spawner: &framework::Spawner, ) { - let camera_mat=glam::Mat3::from_rotation_y(self.camera.yaw); - 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.run(time); - //ALL OF THIS IS TOTALLY WRONG!!! - let walk_target_velocity=self.physics.walkspeed*control_dir; - //autohop (already pressing spacebar; the signal to begin trying to jump is different) - if self.physics.grounded&&walk_target_velocity!=self.physics.walk.target_velocity { - instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{ - time, - instruction:body::PhysicsInstruction::SetWalkTargetVelocity(walk_target_velocity) - }); - } - - if control_dir!=self.physics.temp_control_dir { - instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{ - time, - instruction:body::PhysicsInstruction::SetControlDir(control_dir) - }); - } - - self.physics.jump_trying=self.camera.controls&CONTROL_JUMP!=0; - //autohop (already pressing spacebar; the signal to begin trying to jump is different) - if self.physics.grounded&&self.physics.jump_trying { - //scroll will be implemented with InputInstruction::Jump(true) but it blocks setting self.jump_trying=true - instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{ - time, - instruction:body::PhysicsInstruction::Jump - }); - } - let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None }); // update rotation - let camera_uniforms = self.camera.to_uniform_data(self.physics.body.extrapolated_position(time)); + let camera_uniforms = to_uniform_data(&self.physics.camera,self.physics.body.extrapolated_position(time)); self.staging_belt .write_buffer( &mut encoder,