StrafesNET/strafe-project
6
Fork 4
Code Issues 1 Pull Requests 1 Packages Projects Releases 1 Wiki Activity

replace TIME with Time

Browse Source
This commit is contained in:
Quaternions 2023-10-11 19:17:56 -07:00
parent 4616fd7b3b
commit f16bc043c4
2 changed files with 74 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/integer.rs
View File

@ -1,6 +1,8 @@
//integer units //integer units
#[derive(Clone,Copy,Hash,Debug)]
pub struct Time(i64); pub struct Time(i64);
impl Time{ impl Time{
pub const ZERO:Self=Self(0);
pub const ONE_SECOND:Self=Self(1_000_000_000); pub const ONE_SECOND:Self=Self(1_000_000_000);
pub const ONE_MILLISECOND:Self=Self(1_000_000); pub const ONE_MILLISECOND:Self=Self(1_000_000);
pub const ONE_MICROSECOND:Self=Self(1_000); pub const ONE_MICROSECOND:Self=Self(1_000);
@ -18,6 +20,35 @@ impl Time{
Self(Self::ONE_NANOSECOND.0*num) Self(Self::ONE_NANOSECOND.0*num)
} }
//should I have checked subtraction? force all time variables to be positive? //should I have checked subtraction? force all time variables to be positive?
pub fn nanos(&self)->i64{
self.0
}
}
impl std::fmt::Display for Time{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{}s+{}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
}
}
impl std::ops::Neg for Time{
type Output=Time;
#[inline]
fn neg(self)->Self::Output {
Time(-self.0)
}
}
impl std::ops::Add<Time> for Time{
type Output=Time;
#[inline]
fn add(self,rhs:Self)->Self::Output {
Time(self.0+rhs.0)
}
}
impl std::ops::Sub<Time> for Time{
type Output=Time;
#[inline]
fn sub(self,rhs:Self)->Self::Output {
Time(self.0-rhs.0)
}
} }
#[derive(Clone,Copy,Hash)] #[derive(Clone,Copy,Hash)]

90
src/physics.rs
View File

@ -1,6 +1,6 @@
use crate::{instruction::{InstructionEmitter, InstructionConsumer, TimedInstruction}, zeroes::zeroes2}; use crate::{instruction::{InstructionEmitter, InstructionConsumer, TimedInstruction}, zeroes::zeroes2};
use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Angle32,Angle32Vec2,Ratio64Vec2}; use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
#[derive(Debug)] #[derive(Debug)]
pub enum PhysicsInstruction { pub enum PhysicsInstruction {
@ -54,7 +54,7 @@ pub struct Body {
position: Planar64Vec3,//I64 where 2^32 = 1 u position: Planar64Vec3,//I64 where 2^32 = 1 u
velocity: Planar64Vec3,//I64 where 2^32 = 1 u/s velocity: Planar64Vec3,//I64 where 2^32 = 1 u/s
acceleration: Planar64Vec3,//I64 where 2^32 = 1 u/s/s acceleration: Planar64Vec3,//I64 where 2^32 = 1 u/s/s
time: TIME,//nanoseconds x xxxxD! time:Time,//nanoseconds x xxxxD!
} }
pub enum MoveRestriction { pub enum MoveRestriction {
@ -75,7 +75,7 @@ impl InputState {
} }
} }
impl crate::instruction::InstructionEmitter<InputInstruction> for InputState{ impl crate::instruction::InstructionEmitter<InputInstruction> for InputState{
fn next_instruction(&self, time_limit:crate::body::TIME) -> Option<TimedInstruction<InputInstruction>> { fn next_instruction(&self, time_limit:crate::body::Time) -> Option<TimedInstruction<InputInstruction>> {
//this is polled by PhysicsState for actions like Jump //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. //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) self.queue.get(0)
@ -93,24 +93,24 @@ impl crate::instruction::InstructionConsumer<InputInstruction> for InputState{
#[derive(Clone,Debug)] #[derive(Clone,Debug)]
pub struct MouseState { pub struct MouseState {
pub pos: glam::IVec2, pub pos: glam::IVec2,
pub time: TIME, pub time:Time,
} }
impl Default for MouseState{ impl Default for MouseState{
fn default() -> Self { fn default() -> Self {
Self { Self {
time:0, time:Time::ZERO,
pos:glam::IVec2::ZERO, pos:glam::IVec2::ZERO,
} }
} }
} }
impl MouseState { impl MouseState {
pub fn lerp(&self,target:&MouseState,time:TIME)->glam::IVec2 { pub fn lerp(&self,target:&MouseState,time:Time)->glam::IVec2 {
let m0=self.pos.as_i64vec2(); let m0=self.pos.as_i64vec2();
let m1=target.pos.as_i64vec2(); let m1=target.pos.as_i64vec2();
//these are deltas //these are deltas
let t1t=(target.time-time) as i64; let t1t=(target.time-time).nanos();
let tt0=(time-self.time) as i64; let tt0=(time-self.time).nanos();
let dt=(target.time-self.time) as i64; let dt=(target.time-self.time).nanos();
((m0*t1t+m1*tt0)/dt).as_ivec2() ((m0*t1t+m1*tt0)/dt).as_ivec2()
} }
} }
@ -121,14 +121,14 @@ pub enum WalkEnum{
} }
pub struct WalkState { pub struct WalkState {
pub target_velocity: Planar64Vec3, pub target_velocity: Planar64Vec3,
pub target_time: TIME, pub target_time: Time,
pub state: WalkEnum, pub state: WalkEnum,
} }
impl WalkState { impl WalkState {
pub fn new() -> Self { pub fn new() -> Self {
Self{ Self{
target_velocity:Planar64Vec3::ZERO, target_velocity:Planar64Vec3::ZERO,
target_time:0, target_time:Time::ZERO,
state:WalkEnum::Reached, state:WalkEnum::Reached,
} }
} }
@ -160,7 +160,7 @@ impl PhysicsCamera {
Self{ Self{
offset, offset,
sensitivity:Ratio64Vec2::ONE.mul_ratio(200_000), sensitivity:Ratio64Vec2::ONE.mul_ratio(200_000),
mouse:MouseState{pos:glam::IVec2::ZERO,time:-1},//escape initialization hell divide by zero mouse:MouseState{pos:glam::IVec2::ZERO,time:-Time::ONE_NANOSECOND},//escape initialization hell divide by zero
clamped_mouse_pos:glam::IVec2::ZERO, clamped_mouse_pos:glam::IVec2::ZERO,
angle_pitch_lower_limit:-Angle32::FRAC_PI_2, angle_pitch_lower_limit:-Angle32::FRAC_PI_2,
angle_pitch_upper_limit:Angle32::FRAC_PI_2, angle_pitch_upper_limit:Angle32::FRAC_PI_2,
@ -210,8 +210,7 @@ pub struct StyleModifiers{
pub friction:Planar64, pub friction:Planar64,
pub walk_accel:Planar64, pub walk_accel:Planar64,
pub gravity:Planar64Vec3, pub gravity:Planar64Vec3,
pub strafe_tick_num:TIME, pub strafe_tick_rate:Ratio64,
pub strafe_tick_den:TIME,
pub hitbox_halfsize:Planar64Vec3, pub hitbox_halfsize:Planar64Vec3,
} }
impl std::default::Default for StyleModifiers{ impl std::default::Default for StyleModifiers{
@ -219,8 +218,7 @@ impl std::default::Default for StyleModifiers{
Self{ Self{
controls_mask: !0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN), controls_mask: !0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
controls_held: 0, controls_held: 0,
strafe_tick_num: 100,//100t strafe_tick_rate:Ratio64::ONE.div_ratio(100),
strafe_tick_den: 1_000_000_000,
gravity: Planar64Vec3::new(0,100,0), gravity: Planar64Vec3::new(0,100,0),
friction: Planar64::new(12)/10, friction: Planar64::new(12)/10,
walk_accel: Planar64::new(90), walk_accel: Planar64::new(90),
@ -280,7 +278,7 @@ impl StyleModifiers{
} }
pub struct PhysicsState{ pub struct PhysicsState{
pub time:TIME, pub time:Time,
pub body:Body, pub body:Body,
pub world:WorldState,//currently there is only one state the world can be in pub world:WorldState,//currently there is only one state the world can be in
pub game:GameMechanicsState, pub game:GameMechanicsState,
@ -391,26 +389,24 @@ impl RelativeCollision {
} }
} }
pub type TIME = i64;
impl Body { impl Body {
pub fn with_pva(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3) -> Self { pub fn with_pva(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3) -> Self {
Self{ Self{
position, position,
velocity, velocity,
acceleration, acceleration,
time: 0, time:Time::ZERO,
} }
} }
pub fn extrapolated_position(&self,time: TIME)->Planar64Vec3{ pub fn extrapolated_position(&self,time:Time)->Planar64Vec3{
let dt=(time-self.time) as f64/1_000_000_000f64; let dt=time-self.time;
self.position+self.velocity*(dt as f32)+self.acceleration*((0.5*dt*dt) as f32) self.position+self.velocity*dt+self.acceleration*(dt*dt*0.5)
} }
pub fn extrapolated_velocity(&self,time: TIME)->Planar64Vec3{ pub fn extrapolated_velocity(&self,time:Time)->Planar64Vec3{
let dt=(time-self.time) as f64/1_000_000_000f64; let dt=time-self.time;
self.velocity+self.acceleration*(dt as f32) self.velocity+self.acceleration*dt
} }
pub fn advance_time(&mut self, time: TIME){ pub fn advance_time(&mut self,time:Time){
self.position=self.extrapolated_position(time); self.position=self.extrapolated_position(time);
self.velocity=self.extrapolated_velocity(time); self.velocity=self.extrapolated_velocity(time);
self.time=time; self.time=time;
@ -420,9 +416,9 @@ impl Body {
impl Default for PhysicsState{ impl Default for PhysicsState{
fn default() -> Self { fn default() -> Self {
Self{ Self{
time: 0,
spawn_point:Planar64Vec3::new(0,50,0), spawn_point:Planar64Vec3::new(0,50,0),
body: Body::with_pva(Planar64Vec3::new(0,50,0),Planar64Vec3::new(0,0,0),Planar64Vec3::new(0,-100,0)), body: Body::with_pva(Planar64Vec3::new(0,50,0),Planar64Vec3::new(0,0,0),Planar64Vec3::new(0,-100,0)),
time: Time::ZERO,
style:StyleModifiers::default(), style:StyleModifiers::default(),
grounded: false, grounded: false,
contacts: std::collections::HashMap::new(), contacts: std::collections::HashMap::new(),
@ -628,7 +624,7 @@ impl PhysicsState {
} }
} }
//tickless gaming //tickless gaming
pub fn run(&mut self, time_limit:TIME){ pub fn run(&mut self, time_limit:Time){
//prepare is ommitted - everything is done via instructions. //prepare is ommitted - everything is done via instructions.
while let Some(instruction) = self.next_instruction(time_limit) {//collect while let Some(instruction) = self.next_instruction(time_limit) {//collect
//process //process
@ -637,7 +633,7 @@ impl PhysicsState {
} }
} }
pub fn advance_time(&mut self, time: TIME){ pub fn advance_time(&mut self, time: Time){
self.body.advance_time(time); self.body.advance_time(time);
self.time=time; self.time=time;
} }
@ -672,7 +668,7 @@ impl PhysicsState {
} }
fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> { fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
return Some(TimedInstruction{ return Some(TimedInstruction{
time:(self.time*self.style.strafe_tick_num/self.style.strafe_tick_den+1)*self.style.strafe_tick_den/self.style.strafe_tick_num, time:self.style.strafe_tick_rate.div_int(self.style.strafe_tick_rate.mul_int(self.time)+1),
//only poll the physics if there is a before and after mouse event //only poll the physics if there is a before and after mouse event
instruction:PhysicsInstruction::StrafeTick instruction:PhysicsInstruction::StrafeTick
}); });
@ -727,7 +723,7 @@ impl PhysicsState {
let mut a=target_diff/time_delta; let mut a=target_diff/time_delta;
self.contact_constrain_acceleration(&mut a); self.contact_constrain_acceleration(&mut a);
self.body.acceleration=a; self.body.acceleration=a;
self.walk.target_time=self.body.time+((time_delta as f64)*1_000_000_000f64) as TIME; self.walk.target_time=self.body.time+Time::from(time_delta);
self.walk.state=WalkEnum::Transient; self.walk.state=WalkEnum::Transient;
} }
}else{ }else{
@ -755,7 +751,7 @@ impl PhysicsState {
} }
aabb aabb
} }
fn predict_collision_end(&self,time:TIME,time_limit:TIME,collision_data:&RelativeCollision) -> Option<TimedInstruction<PhysicsInstruction>> { fn predict_collision_end(&self,time:Time,time_limit:Time,collision_data:&RelativeCollision) -> Option<TimedInstruction<PhysicsInstruction>> {
//must treat cancollide false objects differently: you may not exit through the same face you entered. //must treat cancollide false objects differently: you may not exit through the same face you entered.
//RelativeCollsion must reference the full model instead of a particular face //RelativeCollsion must reference the full model instead of a particular face
//this is Ctrl+C Ctrl+V of predict_collision_start but with v=-v before the calc and t=-t after the calc //this is Ctrl+C Ctrl+V of predict_collision_start but with v=-v before the calc and t=-t after the calc
@ -773,7 +769,7 @@ impl PhysicsState {
//must be moving towards surface to collide //must be moving towards surface to collide
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME; let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&0f32<v.x+a.x*-t{ if time<=t_time&&t_time<best_time&&0f32<v.x+a.x*-t{
//collect valid t //collect valid t
best_time=t_time; best_time=t_time;
@ -786,7 +782,7 @@ impl PhysicsState {
//must be moving towards surface to collide //must be moving towards surface to collide
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME; let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&v.x+a.x*-t<0f32{ if time<=t_time&&t_time<best_time&&v.x+a.x*-t<0f32{
//collect valid t //collect valid t
best_time=t_time; best_time=t_time;
@ -818,7 +814,7 @@ impl PhysicsState {
//must be moving towards surface to collide //must be moving towards surface to collide
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME; let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&0f32<v.y+a.y*-t{ if time<=t_time&&t_time<best_time&&0f32<v.y+a.y*-t{
//collect valid t //collect valid t
best_time=t_time; best_time=t_time;
@ -831,7 +827,7 @@ impl PhysicsState {
//must be moving towards surface to collide //must be moving towards surface to collide
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME; let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&v.y+a.y*-t<0f32{ if time<=t_time&&t_time<best_time&&v.y+a.y*-t<0f32{
//collect valid t //collect valid t
best_time=t_time; best_time=t_time;
@ -863,7 +859,7 @@ impl PhysicsState {
//must be moving towards surface to collide //must be moving towards surface to collide
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME; let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&0f32<v.z+a.z*-t{ if time<=t_time&&t_time<best_time&&0f32<v.z+a.z*-t{
//collect valid t //collect valid t
best_time=t_time; best_time=t_time;
@ -876,7 +872,7 @@ impl PhysicsState {
//must be moving towards surface to collide //must be moving towards surface to collide
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as TIME; let t_time=self.body.time+((-t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&v.z+a.z*-t<0f32{ if time<=t_time&&t_time<best_time&&v.z+a.z*-t<0f32{
//collect valid t //collect valid t
best_time=t_time; best_time=t_time;
@ -909,7 +905,7 @@ impl PhysicsState {
} }
None None
} }
fn predict_collision_start(&self,time:TIME,time_limit:TIME,model_id:u32) -> Option<TimedInstruction<PhysicsInstruction>> { fn predict_collision_start(&self,time:Time,time_limit:Time,model_id:u32) -> Option<TimedInstruction<PhysicsInstruction>> {
let mesh0=self.mesh(); let mesh0=self.mesh();
let mesh1=self.models.get(model_id as usize).unwrap().mesh(); let mesh1=self.models.get(model_id as usize).unwrap().mesh();
let (p,v,a,body_time)=(self.body.position,self.body.velocity,self.body.acceleration,self.body.time); let (p,v,a,body_time)=(self.body.position,self.body.velocity,self.body.acceleration,self.body.time);
@ -921,7 +917,7 @@ impl PhysicsState {
//must collide now or in the future //must collide now or in the future
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME; let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&0f32<v.x+a.x*t{ if time<=t_time&&t_time<best_time&&0f32<v.x+a.x*t{
let dp=self.body.extrapolated_position(t_time)-p; let dp=self.body.extrapolated_position(t_time)-p;
//faces must be overlapping //faces must be overlapping
@ -937,7 +933,7 @@ impl PhysicsState {
//must collide now or in the future //must collide now or in the future
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME; let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&v.x+a.x*t<0f32{ if time<=t_time&&t_time<best_time&&v.x+a.x*t<0f32{
let dp=self.body.extrapolated_position(t_time)-p; let dp=self.body.extrapolated_position(t_time)-p;
//faces must be overlapping //faces must be overlapping
@ -954,7 +950,7 @@ impl PhysicsState {
//must collide now or in the future //must collide now or in the future
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME; let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&0f32<v.y+a.y*t{ if time<=t_time&&t_time<best_time&&0f32<v.y+a.y*t{
let dp=self.body.extrapolated_position(t_time)-p; let dp=self.body.extrapolated_position(t_time)-p;
//faces must be overlapping //faces must be overlapping
@ -970,7 +966,7 @@ impl PhysicsState {
//must collide now or in the future //must collide now or in the future
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME; let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&v.y+a.y*t<0f32{ if time<=t_time&&t_time<best_time&&v.y+a.y*t<0f32{
let dp=self.body.extrapolated_position(t_time)-p; let dp=self.body.extrapolated_position(t_time)-p;
//faces must be overlapping //faces must be overlapping
@ -987,7 +983,7 @@ impl PhysicsState {
//must collide now or in the future //must collide now or in the future
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME; let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&0f32<v.z+a.z*t{ if time<=t_time&&t_time<best_time&&0f32<v.z+a.z*t{
let dp=self.body.extrapolated_position(t_time)-p; let dp=self.body.extrapolated_position(t_time)-p;
//faces must be overlapping //faces must be overlapping
@ -1003,7 +999,7 @@ impl PhysicsState {
//must collide now or in the future //must collide now or in the future
//must beat the current soonest collision time //must beat the current soonest collision time
//must be moving towards surface //must be moving towards surface
let t_time=body_time+((t as f64)*1_000_000_000f64) as TIME; let t_time=body_time+((t as f64)*1_000_000_000f64) as Time;
if time<=t_time&&t_time<best_time&&v.z+a.z*t<0f32{ if time<=t_time&&t_time<best_time&&v.z+a.z*t<0f32{
let dp=self.body.extrapolated_position(t_time)-p; let dp=self.body.extrapolated_position(t_time)-p;
//faces must be overlapping //faces must be overlapping
@ -1031,7 +1027,7 @@ impl PhysicsState {
impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState { impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState {
//this little next instruction function can cache its return value and invalidate the cached value by watching the State. //this little next instruction function can cache its return value and invalidate the cached value by watching the State.
fn next_instruction(&self,time_limit:TIME) -> Option<TimedInstruction<PhysicsInstruction>> { fn next_instruction(&self,time_limit:Time) -> Option<TimedInstruction<PhysicsInstruction>> {
//JUST POLLING!!! NO MUTATION //JUST POLLING!!! NO MUTATION
let mut collector = crate::instruction::InstructionCollector::new(time_limit); let mut collector = crate::instruction::InstructionCollector::new(time_limit);
//check for collision stop instructions with curent contacts //check for collision stop instructions with curent contacts