forked from StrafesNET/strafe-client
Compare commits
13 Commits
master
...
mouse-inte
Author | SHA1 | Date | |
---|---|---|---|
ead0e33546 | |||
b376c03bde | |||
d7dc08092a | |||
d898d7cf67 | |||
7f68fd9b21 | |||
0b8a433640 | |||
9646804dcd | |||
9cd72d5809 | |||
9ecfe26a0c | |||
fbb2ba369c | |||
d1f78b6e18 | |||
8cade8134f | |||
3268d92d24 |
749
Cargo.lock
generated
749
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
18
Cargo.toml
18
Cargo.toml
@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "strafe-client"
|
name = "strafe-client"
|
||||||
version = "0.10.5"
|
version = "0.10.1"
|
||||||
edition = "2021"
|
edition = "2021"
|
||||||
repository = "https://git.itzana.me/StrafesNET/strafe-client"
|
repository = "https://git.itzana.me/StrafesNET/strafe-client"
|
||||||
license = "Custom"
|
license = "Custom"
|
||||||
@ -18,17 +18,17 @@ roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
|
|||||||
bytemuck = { version = "1.13.1", features = ["derive"] }
|
bytemuck = { version = "1.13.1", features = ["derive"] }
|
||||||
configparser = "3.0.2"
|
configparser = "3.0.2"
|
||||||
ddsfile = "0.5.1"
|
ddsfile = "0.5.1"
|
||||||
glam = "0.29.0"
|
glam = "0.28.0"
|
||||||
id = { version = "0.1.0", registry = "strafesnet" }
|
id = { version = "0.1.0", registry = "strafesnet" }
|
||||||
parking_lot = "0.12.1"
|
parking_lot = "0.12.1"
|
||||||
pollster = "0.3.0"
|
pollster = "0.3.0"
|
||||||
strafesnet_bsp_loader = { version = "0.2.1", registry = "strafesnet", optional = true }
|
strafesnet_bsp_loader = { version = "0.1.3", registry = "strafesnet", optional = true }
|
||||||
strafesnet_common = { version = "0.5.2", registry = "strafesnet" }
|
strafesnet_common = { version = "0.2.0", registry = "strafesnet" }
|
||||||
strafesnet_deferred_loader = { version = "0.4.0", features = ["legacy"], registry = "strafesnet", optional = true }
|
strafesnet_deferred_loader = { version = "0.3.1", features = ["legacy"], registry = "strafesnet", optional = true }
|
||||||
strafesnet_rbx_loader = { version = "0.5.1", registry = "strafesnet", optional = true }
|
strafesnet_rbx_loader = { version = "0.3.2", registry = "strafesnet", optional = true }
|
||||||
strafesnet_snf = { version = "0.2.0", registry = "strafesnet", optional = true }
|
strafesnet_snf = { version = "0.1.0", registry = "strafesnet", optional = true }
|
||||||
wgpu = "22.1.0"
|
wgpu = "22.0.0"
|
||||||
winit = "0.30.5"
|
winit = "0.30.4"
|
||||||
|
|
||||||
[profile.release]
|
[profile.release]
|
||||||
#lto = true
|
#lto = true
|
||||||
|
@ -1,33 +1,32 @@
|
|||||||
use crate::physics::Body;
|
use crate::physics::Body;
|
||||||
use crate::model_physics::{GigaTime,FEV,MeshQuery,DirectedEdge,MinkowskiMesh,MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert};
|
use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
|
||||||
use strafesnet_common::integer::{Time,Fixed,Ratio};
|
use strafesnet_common::integer::{Time,Planar64};
|
||||||
|
use strafesnet_common::zeroes::zeroes2;
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
enum Transition<F,E:DirectedEdge,V>{
|
enum Transition<F,E:DirectedEdge,V>{
|
||||||
Miss,
|
Miss,
|
||||||
Next(FEV<F,E,V>,GigaTime),
|
Next(FEV<F,E,V>,Time),
|
||||||
Hit(F,GigaTime),
|
Hit(F,Time),
|
||||||
}
|
}
|
||||||
|
|
||||||
type MinkowskiFEV=FEV<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
|
fn next_transition<F:Copy,E:Copy+DirectedEdge,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
|
||||||
type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
|
|
||||||
|
|
||||||
fn next_transition(fev:&MinkowskiFEV,body_time:GigaTime,mesh:&MinkowskiMesh,body:&Body,mut best_time:GigaTime)->MinkowskiTransition{
|
|
||||||
//conflicting derivative means it crosses in the wrong direction.
|
//conflicting derivative means it crosses in the wrong direction.
|
||||||
//if the transition time is equal to an already tested transition, do not replace the current best.
|
//if the transition time is equal to an already tested transition, do not replace the current best.
|
||||||
let mut best_transition=MinkowskiTransition::Miss;
|
let mut best_time=time_limit;
|
||||||
|
let mut best_transtition=Transition::Miss;
|
||||||
match fev{
|
match fev{
|
||||||
&MinkowskiFEV::Face(face_id)=>{
|
&FEV::<F,E,V>::Face(face_id)=>{
|
||||||
//test own face collision time, ignoring roots with zero or conflicting derivative
|
//test own face collision time, ignoring roots with zero or conflicting derivative
|
||||||
//n=face.normal d=face.dot
|
//n=face.normal d=face.dot
|
||||||
//n.a t^2+n.v t+n.p-d==0
|
//n.a t^2+n.v t+n.p-d==0
|
||||||
let (n,d)=mesh.face_nd(face_id);
|
let (n,d)=mesh.face_nd(face_id);
|
||||||
//TODO: use higher precision d value?
|
//TODO: use higher precision d value?
|
||||||
//use the mesh transform translation instead of baking it into the d value.
|
//use the mesh transform translation instead of baking it into the d value.
|
||||||
for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
||||||
if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
|
let t=body.time+Time::from(t);
|
||||||
best_time=dt;
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_transition=MinkowskiTransition::Hit(face_id,dt);
|
best_time=t;
|
||||||
|
best_transtition=Transition::Hit(face_id,t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -37,18 +36,18 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
|
|||||||
let n=n.cross(edge_n);
|
let n=n.cross(edge_n);
|
||||||
let verts=mesh.edge_verts(directed_edge_id.as_undirected());
|
let verts=mesh.edge_verts(directed_edge_id.as_undirected());
|
||||||
//WARNING: d is moved out of the *2 block because of adding two vertices!
|
//WARNING: d is moved out of the *2 block because of adding two vertices!
|
||||||
//WARNING: precision is swept under the rug!
|
for t in zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))),n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
||||||
for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
|
let t=body.time+Time::from(t);
|
||||||
if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=dt;
|
best_time=t;
|
||||||
best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
//if none:
|
//if none:
|
||||||
},
|
},
|
||||||
&MinkowskiFEV::Edge(edge_id)=>{
|
&FEV::<F,E,V>::Edge(edge_id)=>{
|
||||||
//test each face collision time, ignoring roots with zero or conflicting derivative
|
//test each face collision time, ignoring roots with zero or conflicting derivative
|
||||||
let edge_n=mesh.edge_n(edge_id);
|
let edge_n=mesh.edge_n(edge_id);
|
||||||
let edge_verts=mesh.edge_verts(edge_id);
|
let edge_verts=mesh.edge_verts(edge_id);
|
||||||
@ -58,10 +57,11 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
|
|||||||
//edge_n gets parity from the order of edge_faces
|
//edge_n gets parity from the order of edge_faces
|
||||||
let n=face_n.cross(edge_n)*((i as i64)*2-1);
|
let n=face_n.cross(edge_n)*((i as i64)*2-1);
|
||||||
//WARNING yada yada d *2
|
//WARNING yada yada d *2
|
||||||
for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
|
for t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
||||||
if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
|
let t=body.time+Time::from(t);
|
||||||
best_time=dt;
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_transition=MinkowskiTransition::Next(MinkowskiFEV::Face(edge_face_id),dt);
|
best_time=t;
|
||||||
|
best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -70,27 +70,27 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
|
|||||||
for (i,&vert_id) in edge_verts.iter().enumerate(){
|
for (i,&vert_id) in edge_verts.iter().enumerate(){
|
||||||
//vertex normal gets parity from vert index
|
//vertex normal gets parity from vert index
|
||||||
let n=edge_n*(1-2*(i as i64));
|
let n=edge_n*(1-2*(i as i64));
|
||||||
for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
||||||
if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
|
let t=body.time+Time::from(t);
|
||||||
let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=dt;
|
best_time=t;
|
||||||
best_transition=MinkowskiTransition::Next(MinkowskiFEV::Vert(vert_id),dt);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
//if none:
|
//if none:
|
||||||
},
|
},
|
||||||
&MinkowskiFEV::Vert(vert_id)=>{
|
&FEV::<F,E,V>::Vert(vert_id)=>{
|
||||||
//test each edge collision time, ignoring roots with zero or conflicting derivative
|
//test each edge collision time, ignoring roots with zero or conflicting derivative
|
||||||
for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
|
for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
|
||||||
//edge is directed away from vertex, but we want the dot product to turn out negative
|
//edge is directed away from vertex, but we want the dot product to turn out negative
|
||||||
let n=-mesh.directed_edge_n(directed_edge_id);
|
let n=-mesh.directed_edge_n(directed_edge_id);
|
||||||
for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
||||||
if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
|
let t=body.time+Time::from(t);
|
||||||
let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=dt;
|
best_time=t;
|
||||||
best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -98,26 +98,18 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
|
|||||||
//if none:
|
//if none:
|
||||||
},
|
},
|
||||||
}
|
}
|
||||||
best_transition
|
best_transtition
|
||||||
}
|
}
|
||||||
pub enum CrawlResult<F,E:DirectedEdge,V>{
|
pub enum CrawlResult<F,E:DirectedEdge,V>{
|
||||||
Miss(FEV<F,E,V>),
|
Miss(FEV<F,E,V>),
|
||||||
Hit(F,GigaTime),
|
Hit(F,Time),
|
||||||
}
|
}
|
||||||
type MinkowskiCrawlResult=CrawlResult<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
|
pub fn crawl_fev<F:Copy,E:Copy+DirectedEdge,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>{
|
||||||
pub fn crawl_fev(mut fev:MinkowskiFEV,mesh:&MinkowskiMesh,relative_body:&Body,start_time:Time,time_limit:Time)->MinkowskiCrawlResult{
|
let mut time=start_time;
|
||||||
let mut body_time={
|
|
||||||
let r=(start_time-relative_body.time).to_ratio();
|
|
||||||
Ratio::new(r.num.fix_4(),r.den.fix_4())
|
|
||||||
};
|
|
||||||
let time_limit={
|
|
||||||
let r=(time_limit-relative_body.time).to_ratio();
|
|
||||||
Ratio::new(r.num.fix_4(),r.den.fix_4())
|
|
||||||
};
|
|
||||||
for _ in 0..20{
|
for _ in 0..20{
|
||||||
match next_transition(&fev,body_time,mesh,relative_body,time_limit){
|
match next_transition(&fev,time,mesh,relative_body,time_limit){
|
||||||
Transition::Miss=>return CrawlResult::Miss(fev),
|
Transition::Miss=>return CrawlResult::Miss(fev),
|
||||||
Transition::Next(next_fev,next_time)=>(fev,body_time)=(next_fev,next_time),
|
Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
|
||||||
Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
|
Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
11
src/file.rs
11
src/file.rs
@ -22,7 +22,7 @@ impl std::error::Error for ReadError{}
|
|||||||
|
|
||||||
pub enum DataStructure{
|
pub enum DataStructure{
|
||||||
#[cfg(feature="roblox")]
|
#[cfg(feature="roblox")]
|
||||||
Roblox(strafesnet_rbx_loader::Model),
|
Roblox(strafesnet_rbx_loader::Dom),
|
||||||
#[cfg(feature="source")]
|
#[cfg(feature="source")]
|
||||||
Source(strafesnet_bsp_loader::Bsp),
|
Source(strafesnet_bsp_loader::Bsp),
|
||||||
#[cfg(feature="snf")]
|
#[cfg(feature="snf")]
|
||||||
@ -66,16 +66,13 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
|
|||||||
#[cfg(feature="snf")]
|
#[cfg(feature="snf")]
|
||||||
DataStructure::StrafesNET(map)=>Ok(map),
|
DataStructure::StrafesNET(map)=>Ok(map),
|
||||||
#[cfg(feature="roblox")]
|
#[cfg(feature="roblox")]
|
||||||
DataStructure::Roblox(model)=>{
|
DataStructure::Roblox(dom)=>{
|
||||||
let mut place=model.into_place();
|
|
||||||
place.run_scripts();
|
|
||||||
|
|
||||||
let mut loader=strafesnet_deferred_loader::roblox_legacy();
|
let mut loader=strafesnet_deferred_loader::roblox_legacy();
|
||||||
|
|
||||||
let (texture_loader,mesh_loader)=loader.get_inner_mut();
|
let (texture_loader,mesh_loader)=loader.get_inner_mut();
|
||||||
|
|
||||||
let map_step1=strafesnet_rbx_loader::convert(
|
let map_step1=strafesnet_rbx_loader::convert(
|
||||||
&place,
|
&dom,
|
||||||
|name|texture_loader.acquire_render_config_id(name),
|
|name|texture_loader.acquire_render_config_id(name),
|
||||||
|name|mesh_loader.acquire_mesh_id(name),
|
|name|mesh_loader.acquire_mesh_id(name),
|
||||||
);
|
);
|
||||||
@ -113,7 +110,7 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
|
|||||||
|name|mesh_loader.acquire_mesh_id(name),
|
|name|mesh_loader.acquire_mesh_id(name),
|
||||||
);
|
);
|
||||||
|
|
||||||
let prop_meshes=mesh_loader.load_meshes(bsp.as_ref());
|
let prop_meshes=mesh_loader.load_meshes(&bsp.as_ref());
|
||||||
|
|
||||||
let map_step2=map_step1.add_prop_meshes(
|
let map_step2=map_step1.add_prop_meshes(
|
||||||
//the type conflagulator 9000
|
//the type conflagulator 9000
|
||||||
|
@ -6,6 +6,12 @@ use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId,
|
|||||||
use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
|
use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
|
||||||
use crate::model_graphics::{self,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
|
use crate::model_graphics::{self,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct GraphicsModelUpdate{
|
||||||
|
transform:Option<glam::Mat4>,
|
||||||
|
color:Option<glam::Vec4>,
|
||||||
|
}
|
||||||
|
|
||||||
struct Indices{
|
struct Indices{
|
||||||
count:u32,
|
count:u32,
|
||||||
buf:wgpu::Buffer,
|
buf:wgpu::Buffer,
|
||||||
@ -26,6 +32,7 @@ impl Indices{
|
|||||||
}
|
}
|
||||||
struct GraphicsModel{
|
struct GraphicsModel{
|
||||||
indices:Indices,
|
indices:Indices,
|
||||||
|
model_buf:wgpu::Buffer,
|
||||||
vertex_buf:wgpu::Buffer,
|
vertex_buf:wgpu::Buffer,
|
||||||
bind_group:wgpu::BindGroup,
|
bind_group:wgpu::BindGroup,
|
||||||
instance_count:u32,
|
instance_count:u32,
|
||||||
@ -58,12 +65,12 @@ struct GraphicsCamera{
|
|||||||
#[inline]
|
#[inline]
|
||||||
fn perspective_rh(fov_x_slope:f32,fov_y_slope:f32,z_near:f32,z_far:f32)->glam::Mat4{
|
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);
|
//glam_assert!(z_near > 0.0 && z_far > 0.0);
|
||||||
let r=z_far/(z_near-z_far);
|
let r=z_far / (z_near-z_far);
|
||||||
glam::Mat4::from_cols(
|
glam::Mat4::from_cols(
|
||||||
glam::Vec4::new(1.0/fov_x_slope,0.0,0.0,0.0),
|
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,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,-1.0),
|
||||||
glam::Vec4::new(0.0,0.0,r*z_near,0.0),
|
glam::Vec4::new(0.0,0.0,r * z_near,0.0),
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
impl GraphicsCamera{
|
impl GraphicsCamera{
|
||||||
@ -72,10 +79,10 @@ impl GraphicsCamera{
|
|||||||
}
|
}
|
||||||
pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
|
pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
|
||||||
//f32 good enough for view matrix
|
//f32 good enough for view matrix
|
||||||
glam::Mat4::from_translation(pos)*glam::Mat4::from_euler(glam::EulerRot::YXZ,angles.x,angles.y,0f32)
|
glam::Mat4::from_translation(pos) * glam::Mat4::from_euler(glam::EulerRot::YXZ,angles.x,angles.y,0f32)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_uniform_data(&self,pos:glam::Vec3,angles:glam::Vec2)->[f32;16*4]{
|
pub fn to_uniform_data(&self,(pos,angles):(glam::Vec3,glam::Vec2))->[f32; 16 * 4]{
|
||||||
let proj=self.proj();
|
let proj=self.proj();
|
||||||
let proj_inv=proj.inverse();
|
let proj_inv=proj.inverse();
|
||||||
let view_inv=self.world(pos,angles);
|
let view_inv=self.world(pos,angles);
|
||||||
@ -98,12 +105,6 @@ impl std::default::Default for GraphicsCamera{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct FrameState{
|
|
||||||
pub body:crate::physics::Body,
|
|
||||||
pub camera:crate::physics::PhysicsCamera,
|
|
||||||
pub time:integer::Time,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct GraphicsState{
|
pub struct GraphicsState{
|
||||||
pipelines:GraphicsPipelines,
|
pipelines:GraphicsPipelines,
|
||||||
bind_groups:GraphicsBindGroups,
|
bind_groups:GraphicsBindGroups,
|
||||||
@ -219,7 +220,7 @@ impl GraphicsState{
|
|||||||
//wow
|
//wow
|
||||||
let instance=GraphicsModelOwned{
|
let instance=GraphicsModelOwned{
|
||||||
transform:model.transform.into(),
|
transform:model.transform.into(),
|
||||||
normal_transform:glam::Mat3::from_cols_array_2d(&model.transform.matrix3.to_array().map(|row|row.map(Into::into))).inverse().transpose(),
|
normal_transform:Into::<glam::Mat3>::into(model.transform.matrix3).inverse().transpose(),
|
||||||
color:GraphicsModelColor4::new(model.color),
|
color:GraphicsModelColor4::new(model.color),
|
||||||
};
|
};
|
||||||
//get or create owned mesh map
|
//get or create owned mesh map
|
||||||
@ -238,9 +239,9 @@ impl GraphicsState{
|
|||||||
//create
|
//create
|
||||||
let owned_mesh_id=IndexedGraphicsMeshOwnedRenderConfigId::new(unique_render_config_models.len() as u32);
|
let owned_mesh_id=IndexedGraphicsMeshOwnedRenderConfigId::new(unique_render_config_models.len() as u32);
|
||||||
unique_render_config_models.push(IndexedGraphicsMeshOwnedRenderConfig{
|
unique_render_config_models.push(IndexedGraphicsMeshOwnedRenderConfig{
|
||||||
unique_pos:mesh.unique_pos.iter().map(|v|v.to_array().map(Into::into)).collect(),
|
unique_pos:mesh.unique_pos.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
|
||||||
unique_tex:mesh.unique_tex.iter().map(|v|*v.as_ref()).collect(),
|
unique_tex:mesh.unique_tex.iter().map(|v|*v.as_ref()).collect(),
|
||||||
unique_normal:mesh.unique_normal.iter().map(|v|v.to_array().map(Into::into)).collect(),
|
unique_normal:mesh.unique_normal.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
|
||||||
unique_color:mesh.unique_color.iter().map(|v|*v.as_ref()).collect(),
|
unique_color:mesh.unique_color.iter().map(|v|*v.as_ref()).collect(),
|
||||||
unique_vertices:mesh.unique_vertices.clone(),
|
unique_vertices:mesh.unique_vertices.clone(),
|
||||||
render_config:graphics_group.render,
|
render_config:graphics_group.render,
|
||||||
@ -506,6 +507,7 @@ impl GraphicsState{
|
|||||||
model_graphics::Indices::U16(indices)=>Indices::new(device,indices,wgpu::IndexFormat::Uint16),
|
model_graphics::Indices::U16(indices)=>Indices::new(device,indices,wgpu::IndexFormat::Uint16),
|
||||||
},
|
},
|
||||||
bind_group,
|
bind_group,
|
||||||
|
model_buf,
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -814,7 +816,7 @@ impl GraphicsState{
|
|||||||
});
|
});
|
||||||
|
|
||||||
let camera=GraphicsCamera::default();
|
let camera=GraphicsCamera::default();
|
||||||
let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
|
let camera_uniforms=camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(crate::physics::MouseState::default()));
|
||||||
let camera_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
|
let camera_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
|
||||||
label:Some("Camera"),
|
label:Some("Camera"),
|
||||||
contents:bytemuck::cast_slice(&camera_uniforms),
|
contents:bytemuck::cast_slice(&camera_uniforms),
|
||||||
@ -882,17 +884,16 @@ impl GraphicsState{
|
|||||||
view:&wgpu::TextureView,
|
view:&wgpu::TextureView,
|
||||||
device:&wgpu::Device,
|
device:&wgpu::Device,
|
||||||
queue:&wgpu::Queue,
|
queue:&wgpu::Queue,
|
||||||
frame_state:FrameState,
|
physics_output:crate::physics::PhysicsOutputState,
|
||||||
|
predicted_time:integer::Time,
|
||||||
|
mouse_pos:glam::IVec2,
|
||||||
){
|
){
|
||||||
//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
|
//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
|
||||||
|
|
||||||
let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
|
let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
|
||||||
|
|
||||||
// update rotation
|
// update rotation
|
||||||
let camera_uniforms=self.camera.to_uniform_data(
|
let camera_uniforms=self.camera.to_uniform_data(physics_output.extrapolate(crate::physics::MouseState{pos:mouse_pos,time:predicted_time}));
|
||||||
frame_state.body.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
|
|
||||||
frame_state.camera.simulate_move_angles(glam::IVec2::ZERO)
|
|
||||||
);
|
|
||||||
self.staging_belt
|
self.staging_belt
|
||||||
.write_buffer(
|
.write_buffer(
|
||||||
&mut encoder,
|
&mut encoder,
|
||||||
|
@ -1,8 +1,11 @@
|
|||||||
|
use strafesnet_common::integer;
|
||||||
|
|
||||||
pub enum Instruction{
|
pub enum Instruction{
|
||||||
Render(crate::graphics::FrameState),
|
Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2),
|
||||||
//UpdateModel(crate::graphics::GraphicsModelUpdate),
|
//UpdateModel(crate::graphics::GraphicsModelUpdate),
|
||||||
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
|
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
|
||||||
ChangeMap(strafesnet_common::map::CompleteMap),
|
GenerateModels(strafesnet_common::map::CompleteMap),
|
||||||
|
ClearModels,
|
||||||
}
|
}
|
||||||
|
|
||||||
//Ideally the graphics thread worker description is:
|
//Ideally the graphics thread worker description is:
|
||||||
@ -20,27 +23,31 @@ pub fn new<'a>(
|
|||||||
surface:wgpu::Surface<'a>,
|
surface:wgpu::Surface<'a>,
|
||||||
device:wgpu::Device,
|
device:wgpu::Device,
|
||||||
queue:wgpu::Queue,
|
queue:wgpu::Queue,
|
||||||
)->crate::compat_worker::INWorker<'a,Instruction>{
|
)->crate::compat_worker::INWorker<'a,Instruction>{
|
||||||
let mut resize=None;
|
let mut resize=None;
|
||||||
crate::compat_worker::INWorker::new(move |ins:Instruction|{
|
crate::compat_worker::INWorker::new(move |ins:Instruction|{
|
||||||
match ins{
|
match ins{
|
||||||
Instruction::ChangeMap(map)=>{
|
Instruction::GenerateModels(map)=>{
|
||||||
graphics.clear();
|
|
||||||
graphics.generate_models(&device,&queue,&map);
|
graphics.generate_models(&device,&queue,&map);
|
||||||
},
|
},
|
||||||
|
Instruction::ClearModels=>{
|
||||||
|
graphics.clear();
|
||||||
|
},
|
||||||
Instruction::Resize(size,user_settings)=>{
|
Instruction::Resize(size,user_settings)=>{
|
||||||
resize=Some((size,user_settings));
|
resize=Some((size,user_settings));
|
||||||
}
|
}
|
||||||
Instruction::Render(frame_state)=>{
|
Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
|
||||||
if let Some((size,user_settings))=resize.take(){
|
if let Some((size,user_settings))=&resize{
|
||||||
println!("Resizing to {:?}",size);
|
println!("Resizing to {:?}",size);
|
||||||
let t0=std::time::Instant::now();
|
let t0=std::time::Instant::now();
|
||||||
config.width=size.width.max(1);
|
config.width=size.width.max(1);
|
||||||
config.height=size.height.max(1);
|
config.height=size.height.max(1);
|
||||||
surface.configure(&device,&config);
|
surface.configure(&device,&config);
|
||||||
graphics.resize(&device,&config,&user_settings);
|
graphics.resize(&device,&config,user_settings);
|
||||||
println!("Resize took {:?}",t0.elapsed());
|
println!("Resize took {:?}",t0.elapsed());
|
||||||
}
|
}
|
||||||
|
//clear every time w/e
|
||||||
|
resize=None;
|
||||||
//this has to go deeper somehow
|
//this has to go deeper somehow
|
||||||
let frame=match surface.get_current_texture(){
|
let frame=match surface.get_current_texture(){
|
||||||
Ok(frame)=>frame,
|
Ok(frame)=>frame,
|
||||||
@ -56,7 +63,7 @@ pub fn new<'a>(
|
|||||||
..wgpu::TextureViewDescriptor::default()
|
..wgpu::TextureViewDescriptor::default()
|
||||||
});
|
});
|
||||||
|
|
||||||
graphics.render(&view,&device,&queue,frame_state);
|
graphics.render(&view,&device,&queue,physics_output,predicted_time,mouse_pos);
|
||||||
|
|
||||||
frame.present();
|
frame.present();
|
||||||
}
|
}
|
||||||
|
@ -1,5 +1,6 @@
|
|||||||
mod file;
|
mod file;
|
||||||
mod setup;
|
mod setup;
|
||||||
|
mod timer;
|
||||||
mod window;
|
mod window;
|
||||||
mod worker;
|
mod worker;
|
||||||
mod physics;
|
mod physics;
|
||||||
|
@ -1,15 +1,15 @@
|
|||||||
use std::borrow::{Borrow,Cow};
|
use std::borrow::{Borrow,Cow};
|
||||||
use std::collections::{HashSet,HashMap};
|
use std::collections::{HashSet,HashMap};
|
||||||
use strafesnet_common::integer::vec3::Vector3;
|
|
||||||
use strafesnet_common::model::{self,MeshId,PolygonIter};
|
use strafesnet_common::model::{self,MeshId,PolygonIter};
|
||||||
use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
|
use strafesnet_common::zeroes;
|
||||||
|
use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
|
||||||
|
|
||||||
pub trait UndirectedEdge{
|
pub trait UndirectedEdge{
|
||||||
type DirectedEdge:Copy+DirectedEdge;
|
type DirectedEdge:Copy+DirectedEdge;
|
||||||
fn as_directed(&self,parity:bool)->Self::DirectedEdge;
|
fn as_directed(&self,parity:bool)->Self::DirectedEdge;
|
||||||
}
|
}
|
||||||
pub trait DirectedEdge{
|
pub trait DirectedEdge{
|
||||||
type UndirectedEdge:Copy+std::fmt::Debug+UndirectedEdge;
|
type UndirectedEdge:Copy+UndirectedEdge;
|
||||||
fn as_undirected(&self)->Self::UndirectedEdge;
|
fn as_undirected(&self)->Self::UndirectedEdge;
|
||||||
fn parity(&self)->bool;
|
fn parity(&self)->bool;
|
||||||
//this is stupid but may work fine
|
//this is stupid but may work fine
|
||||||
@ -50,7 +50,6 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
|
|||||||
}
|
}
|
||||||
|
|
||||||
//Vertex <-> Edge <-> Face -> Collide
|
//Vertex <-> Edge <-> Face -> Collide
|
||||||
#[derive(Debug)]
|
|
||||||
pub enum FEV<F,E:DirectedEdge,V>{
|
pub enum FEV<F,E:DirectedEdge,V>{
|
||||||
Face(F),
|
Face(F),
|
||||||
Edge(E::UndirectedEdge),
|
Edge(E::UndirectedEdge),
|
||||||
@ -65,9 +64,6 @@ struct Face{
|
|||||||
}
|
}
|
||||||
struct Vert(Planar64Vec3);
|
struct Vert(Planar64Vec3);
|
||||||
pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
|
pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
|
||||||
// Vertex must be Planar64Vec3 because it represents an actual position
|
|
||||||
type Normal;
|
|
||||||
type Offset;
|
|
||||||
fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
|
fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
|
||||||
let verts=self.edge_verts(edge_id);
|
let verts=self.edge_verts(edge_id);
|
||||||
self.vert(verts[1].clone())-self.vert(verts[0].clone())
|
self.vert(verts[1].clone())-self.vert(verts[0].clone())
|
||||||
@ -77,7 +73,7 @@ pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
|
|||||||
(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
|
(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
|
||||||
}
|
}
|
||||||
fn vert(&self,vert_id:VERT)->Planar64Vec3;
|
fn vert(&self,vert_id:VERT)->Planar64Vec3;
|
||||||
fn face_nd(&self,face_id:FACE)->(Self::Normal,Self::Offset);
|
fn face_nd(&self,face_id:FACE)->(Planar64Vec3,Planar64);
|
||||||
fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
|
fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
|
||||||
fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
|
fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
|
||||||
fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
|
fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
|
||||||
@ -141,22 +137,22 @@ impl PhysicsMesh{
|
|||||||
//go go gadget debug print mesh
|
//go go gadget debug print mesh
|
||||||
let data=PhysicsMeshData{
|
let data=PhysicsMeshData{
|
||||||
faces:vec![
|
faces:vec![
|
||||||
Face{normal:vec3::raw_xyz( 4294967296, 0, 0),dot:Planar64::raw(4294967296)},
|
Face{normal:Planar64Vec3::raw_xyz( 4294967296, 0, 0),dot:Planar64::raw(4294967296)},
|
||||||
Face{normal:vec3::raw_xyz( 0, 4294967296, 0),dot:Planar64::raw(4294967296)},
|
Face{normal:Planar64Vec3::raw_xyz( 0, 4294967296, 0),dot:Planar64::raw(4294967296)},
|
||||||
Face{normal:vec3::raw_xyz( 0, 0, 4294967296),dot:Planar64::raw(4294967296)},
|
Face{normal:Planar64Vec3::raw_xyz( 0, 0, 4294967296),dot:Planar64::raw(4294967296)},
|
||||||
Face{normal:vec3::raw_xyz(-4294967296, 0, 0),dot:Planar64::raw(4294967296)},
|
Face{normal:Planar64Vec3::raw_xyz(-4294967296, 0, 0),dot:Planar64::raw(4294967296)},
|
||||||
Face{normal:vec3::raw_xyz( 0,-4294967296, 0),dot:Planar64::raw(4294967296)},
|
Face{normal:Planar64Vec3::raw_xyz( 0,-4294967296, 0),dot:Planar64::raw(4294967296)},
|
||||||
Face{normal:vec3::raw_xyz( 0, 0,-4294967296),dot:Planar64::raw(4294967296)}
|
Face{normal:Planar64Vec3::raw_xyz( 0, 0,-4294967296),dot:Planar64::raw(4294967296)}
|
||||||
],
|
],
|
||||||
verts:vec![
|
verts:vec![
|
||||||
Vert(vec3::raw_xyz( 4294967296,-4294967296,-4294967296)),
|
Vert(Planar64Vec3::raw_xyz( 4294967296,-4294967296,-4294967296)),
|
||||||
Vert(vec3::raw_xyz( 4294967296, 4294967296,-4294967296)),
|
Vert(Planar64Vec3::raw_xyz( 4294967296, 4294967296,-4294967296)),
|
||||||
Vert(vec3::raw_xyz( 4294967296, 4294967296, 4294967296)),
|
Vert(Planar64Vec3::raw_xyz( 4294967296, 4294967296, 4294967296)),
|
||||||
Vert(vec3::raw_xyz( 4294967296,-4294967296, 4294967296)),
|
Vert(Planar64Vec3::raw_xyz( 4294967296,-4294967296, 4294967296)),
|
||||||
Vert(vec3::raw_xyz(-4294967296, 4294967296,-4294967296)),
|
Vert(Planar64Vec3::raw_xyz(-4294967296, 4294967296,-4294967296)),
|
||||||
Vert(vec3::raw_xyz(-4294967296, 4294967296, 4294967296)),
|
Vert(Planar64Vec3::raw_xyz(-4294967296, 4294967296, 4294967296)),
|
||||||
Vert(vec3::raw_xyz(-4294967296,-4294967296, 4294967296)),
|
Vert(Planar64Vec3::raw_xyz(-4294967296,-4294967296, 4294967296)),
|
||||||
Vert(vec3::raw_xyz(-4294967296,-4294967296,-4294967296))
|
Vert(Planar64Vec3::raw_xyz(-4294967296,-4294967296,-4294967296))
|
||||||
]
|
]
|
||||||
};
|
};
|
||||||
let mesh_topology=PhysicsMeshTopology{
|
let mesh_topology=PhysicsMeshTopology{
|
||||||
@ -334,7 +330,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
|
|||||||
for poly_vertices in polygon_group.polys(){
|
for poly_vertices in polygon_group.polys(){
|
||||||
let submesh_face_id=SubmeshFaceId::new(submesh_faces.len() as u32);
|
let submesh_face_id=SubmeshFaceId::new(submesh_faces.len() as u32);
|
||||||
//one face per poly
|
//one face per poly
|
||||||
let mut normal=Vector3::new([Fixed::ZERO,Fixed::ZERO,Fixed::ZERO]);
|
let mut normal=Planar64Vec3::ZERO;
|
||||||
let len=poly_vertices.len();
|
let len=poly_vertices.len();
|
||||||
let face_edges=poly_vertices.into_iter().enumerate().map(|(i,vert_id)|{
|
let face_edges=poly_vertices.into_iter().enumerate().map(|(i,vert_id)|{
|
||||||
let vert0_id=MeshVertId::new(mesh.unique_vertices[vert_id.get() as usize].pos.get() as u32);
|
let vert0_id=MeshVertId::new(mesh.unique_vertices[vert_id.get() as usize].pos.get() as u32);
|
||||||
@ -345,11 +341,11 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
|
|||||||
//https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal (Newell's Method)
|
//https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal (Newell's Method)
|
||||||
let v0=mesh.unique_pos[vert0_id.get() as usize];
|
let v0=mesh.unique_pos[vert0_id.get() as usize];
|
||||||
let v1=mesh.unique_pos[vert1_id.get() as usize];
|
let v1=mesh.unique_pos[vert1_id.get() as usize];
|
||||||
normal+=Vector3::new([
|
normal+=Planar64Vec3::new(
|
||||||
(v0.y-v1.y)*(v0.z+v1.z),
|
(v0.y()-v1.y())*(v0.z()+v1.z()),
|
||||||
(v0.z-v1.z)*(v0.x+v1.x),
|
(v0.z()-v1.z())*(v0.x()+v1.x()),
|
||||||
(v0.x-v1.x)*(v0.y+v1.y),
|
(v0.x()-v1.x())*(v0.y()+v1.y()),
|
||||||
]);
|
);
|
||||||
//get/create edge and push face into it
|
//get/create edge and push face into it
|
||||||
let (edge_ref_verts,is_sorted)=EdgeRefVerts::new(submesh_vert0_id,submesh_vert1_id);
|
let (edge_ref_verts,is_sorted)=EdgeRefVerts::new(submesh_vert0_id,submesh_vert1_id);
|
||||||
let (edge_ref_faces,edge_id)=edge_pool.push(edge_ref_verts);
|
let (edge_ref_faces,edge_id)=edge_pool.push(edge_ref_verts);
|
||||||
@ -366,16 +362,14 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
|
|||||||
//return directed_edge_id
|
//return directed_edge_id
|
||||||
edge_id.as_directed(is_sorted)
|
edge_id.as_directed(is_sorted)
|
||||||
}).collect();
|
}).collect();
|
||||||
let mut dot=Fixed::ZERO;
|
//choose precision loss randomly idk
|
||||||
// find the average dot
|
normal=normal/len as i64;
|
||||||
|
let mut dot=Planar64::ZERO;
|
||||||
for &v in poly_vertices{
|
for &v in poly_vertices{
|
||||||
dot+=normal.dot(mesh.unique_pos[mesh.unique_vertices[v.get() as usize].pos.get() as usize]);
|
dot+=normal.dot(mesh.unique_pos[mesh.unique_vertices[v.get() as usize].pos.get() as usize]);
|
||||||
}
|
}
|
||||||
//assume face hash is stable, and there are no flush faces...
|
//assume face hash is stable, and there are no flush faces...
|
||||||
let face=Face{
|
let face=Face{normal,dot:dot/len as i64};
|
||||||
normal:(normal/len as i64).divide().fix_1(),
|
|
||||||
dot:(dot/(len*len) as i64).fix_1(),
|
|
||||||
};
|
|
||||||
let face_id=match face_id_from_face.get(&face){
|
let face_id=match face_id_from_face.get(&face){
|
||||||
Some(&face_id)=>face_id,
|
Some(&face_id)=>face_id,
|
||||||
None=>{
|
None=>{
|
||||||
@ -422,8 +416,6 @@ pub struct PhysicsMeshView<'a>{
|
|||||||
topology:&'a PhysicsMeshTopology,
|
topology:&'a PhysicsMeshTopology,
|
||||||
}
|
}
|
||||||
impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMeshView<'_>{
|
impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMeshView<'_>{
|
||||||
type Normal=Planar64Vec3;
|
|
||||||
type Offset=Planar64;
|
|
||||||
fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
|
fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
|
||||||
let face_idx=self.topology.faces[face_id.get() as usize].get() as usize;
|
let face_idx=self.topology.faces[face_id.get() as usize].get() as usize;
|
||||||
(self.data.faces[face_idx].normal,self.data.faces[face_idx].dot)
|
(self.data.faces[face_idx].normal,self.data.faces[face_idx].dot)
|
||||||
@ -452,14 +444,14 @@ impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMes
|
|||||||
|
|
||||||
pub struct PhysicsMeshTransform{
|
pub struct PhysicsMeshTransform{
|
||||||
pub vertex:integer::Planar64Affine3,
|
pub vertex:integer::Planar64Affine3,
|
||||||
pub normal:integer::mat3::Matrix3<Fixed<2,64>>,
|
pub normal:integer::Planar64Mat3,
|
||||||
pub det:Fixed<3,96>,
|
pub det:Planar64,
|
||||||
}
|
}
|
||||||
impl PhysicsMeshTransform{
|
impl PhysicsMeshTransform{
|
||||||
pub fn new(transform:integer::Planar64Affine3)->Self{
|
pub const fn new(transform:integer::Planar64Affine3)->Self{
|
||||||
Self{
|
Self{
|
||||||
normal:transform.matrix3.adjugate().transpose(),
|
normal:transform.matrix3.inverse_times_det().transpose(),
|
||||||
det:transform.matrix3.det(),
|
det:transform.matrix3.determinant(),
|
||||||
vertex:transform,
|
vertex:transform,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -470,7 +462,7 @@ pub struct TransformedMesh<'a>{
|
|||||||
transform:&'a PhysicsMeshTransform,
|
transform:&'a PhysicsMeshTransform,
|
||||||
}
|
}
|
||||||
impl TransformedMesh<'_>{
|
impl TransformedMesh<'_>{
|
||||||
pub const fn new<'a>(
|
pub fn new<'a>(
|
||||||
view:PhysicsMeshView<'a>,
|
view:PhysicsMeshView<'a>,
|
||||||
transform:&'a PhysicsMeshTransform,
|
transform:&'a PhysicsMeshTransform,
|
||||||
)->TransformedMesh<'a>{
|
)->TransformedMesh<'a>{
|
||||||
@ -479,33 +471,33 @@ impl TransformedMesh<'_>{
|
|||||||
transform,
|
transform,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
|
pub fn verts<'a>(&'a self)->impl Iterator<Item=Planar64Vec3>+'a{
|
||||||
self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
|
self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
|
||||||
}
|
}
|
||||||
fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
|
fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
|
||||||
|
let mut best_dot=Planar64::MIN;
|
||||||
|
let mut best_vert=SubmeshVertId(0);
|
||||||
//this happens to be well-defined. there are no virtual virtices
|
//this happens to be well-defined. there are no virtual virtices
|
||||||
SubmeshVertId::new(
|
for (i,vert_id) in self.view.topology.verts.iter().enumerate(){
|
||||||
self.view.topology.verts.iter()
|
let p=self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0);
|
||||||
.enumerate()
|
let d=dir.dot(p);
|
||||||
.max_by_key(|(_,&vert_id)|
|
if best_dot<d{
|
||||||
dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
|
best_dot=d;
|
||||||
)
|
best_vert=SubmeshVertId::new(i as u32);
|
||||||
//assume there is more than zero vertices.
|
}
|
||||||
.unwrap().0 as u32
|
}
|
||||||
)
|
best_vert
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for TransformedMesh<'_>{
|
impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for TransformedMesh<'_>{
|
||||||
type Normal=Vector3<Fixed<3,96>>;
|
fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
|
||||||
type Offset=Fixed<4,128>;
|
|
||||||
fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
|
|
||||||
let (n,d)=self.view.face_nd(face_id);
|
let (n,d)=self.view.face_nd(face_id);
|
||||||
let transformed_n=self.transform.normal*n;
|
let transformed_n=self.transform.normal*n;
|
||||||
let transformed_d=d*self.transform.det+transformed_n.dot(self.transform.vertex.translation);
|
let transformed_d=d+transformed_n.dot(self.transform.vertex.translation)/self.transform.det;
|
||||||
(transformed_n,transformed_d)
|
(transformed_n/self.transform.det,transformed_d)
|
||||||
}
|
}
|
||||||
fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
|
fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
|
||||||
self.transform.vertex.transform_point3(self.view.vert(vert_id)).fix_1()
|
self.transform.vertex.transform_point3(self.view.vert(vert_id))
|
||||||
}
|
}
|
||||||
#[inline]
|
#[inline]
|
||||||
fn face_edges(&self,face_id:SubmeshFaceId)->Cow<Vec<SubmeshDirectedEdgeId>>{
|
fn face_edges(&self,face_id:SubmeshFaceId)->Cow<Vec<SubmeshDirectedEdgeId>>{
|
||||||
@ -533,11 +525,11 @@ impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for Transforme
|
|||||||
//(face,vertex)
|
//(face,vertex)
|
||||||
//(edge,edge)
|
//(edge,edge)
|
||||||
//(vertex,face)
|
//(vertex,face)
|
||||||
#[derive(Clone,Copy,Debug)]
|
#[derive(Clone,Copy)]
|
||||||
pub enum MinkowskiVert{
|
pub enum MinkowskiVert{
|
||||||
VertVert(SubmeshVertId,SubmeshVertId),
|
VertVert(SubmeshVertId,SubmeshVertId),
|
||||||
}
|
}
|
||||||
#[derive(Clone,Copy,Debug)]
|
#[derive(Clone,Copy)]
|
||||||
pub enum MinkowskiEdge{
|
pub enum MinkowskiEdge{
|
||||||
VertEdge(SubmeshVertId,SubmeshEdgeId),
|
VertEdge(SubmeshVertId,SubmeshEdgeId),
|
||||||
EdgeVert(SubmeshEdgeId,SubmeshVertId),
|
EdgeVert(SubmeshEdgeId,SubmeshVertId),
|
||||||
@ -552,7 +544,7 @@ impl UndirectedEdge for MinkowskiEdge{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[derive(Clone,Copy,Debug)]
|
#[derive(Clone,Copy)]
|
||||||
pub enum MinkowskiDirectedEdge{
|
pub enum MinkowskiDirectedEdge{
|
||||||
VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
|
VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
|
||||||
EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
|
EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
|
||||||
@ -573,7 +565,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
|
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
||||||
pub enum MinkowskiFace{
|
pub enum MinkowskiFace{
|
||||||
VertFace(SubmeshVertId,SubmeshFaceId),
|
VertFace(SubmeshVertId,SubmeshFaceId),
|
||||||
EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
|
EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
|
||||||
@ -589,7 +581,6 @@ pub struct MinkowskiMesh<'a>{
|
|||||||
}
|
}
|
||||||
|
|
||||||
//infinity fev algorithm state transition
|
//infinity fev algorithm state transition
|
||||||
#[derive(Debug)]
|
|
||||||
enum Transition{
|
enum Transition{
|
||||||
Done,//found closest vert, no edges are better
|
Done,//found closest vert, no edges are better
|
||||||
Vert(MinkowskiVert),//transition to vert
|
Vert(MinkowskiVert),//transition to vert
|
||||||
@ -599,8 +590,6 @@ enum EV{
|
|||||||
Edge(MinkowskiEdge),
|
Edge(MinkowskiEdge),
|
||||||
}
|
}
|
||||||
|
|
||||||
pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
|
|
||||||
|
|
||||||
impl MinkowskiMesh<'_>{
|
impl MinkowskiMesh<'_>{
|
||||||
pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
|
pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
|
||||||
MinkowskiMesh{
|
MinkowskiMesh{
|
||||||
@ -611,7 +600,7 @@ impl MinkowskiMesh<'_>{
|
|||||||
fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
|
fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
|
||||||
MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
|
MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
|
||||||
}
|
}
|
||||||
fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
|
fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
|
||||||
let mut best_transition=Transition::Done;
|
let mut best_transition=Transition::Done;
|
||||||
for &directed_edge_id in self.vert_edges(vert_id).iter(){
|
for &directed_edge_id in self.vert_edges(vert_id).iter(){
|
||||||
let edge_n=self.directed_edge_n(directed_edge_id);
|
let edge_n=self.directed_edge_n(directed_edge_id);
|
||||||
@ -621,7 +610,7 @@ impl MinkowskiMesh<'_>{
|
|||||||
let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
|
let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
|
||||||
//test if it's closer
|
//test if it's closer
|
||||||
let diff=point-self.vert(test_vert_id);
|
let diff=point-self.vert(test_vert_id);
|
||||||
if edge_n.dot(infinity_dir).is_zero(){
|
if zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
|
||||||
let distance_squared=diff.dot(diff);
|
let distance_squared=diff.dot(diff);
|
||||||
if distance_squared<*best_distance_squared{
|
if distance_squared<*best_distance_squared{
|
||||||
best_transition=Transition::Vert(test_vert_id);
|
best_transition=Transition::Vert(test_vert_id);
|
||||||
@ -631,21 +620,21 @@ impl MinkowskiMesh<'_>{
|
|||||||
}
|
}
|
||||||
best_transition
|
best_transition
|
||||||
}
|
}
|
||||||
fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
|
fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
|
||||||
let mut best_transition=EV::Vert(vert_id);
|
let mut best_transition=EV::Vert(vert_id);
|
||||||
let diff=point-self.vert(vert_id);
|
let diff=point-self.vert(vert_id);
|
||||||
for &directed_edge_id in self.vert_edges(vert_id).iter(){
|
for &directed_edge_id in self.vert_edges(vert_id).iter(){
|
||||||
let edge_n=self.directed_edge_n(directed_edge_id);
|
let edge_n=self.directed_edge_n(directed_edge_id);
|
||||||
//is boundary uncrossable by a crawl from infinity
|
//is boundary uncrossable by a crawl from infinity
|
||||||
//check if time of collision is outside Time::MIN..Time::MAX
|
//check if time of collision is outside Time::MIN..Time::MAX
|
||||||
if edge_n.dot(infinity_dir).is_zero(){
|
|
||||||
let d=edge_n.dot(diff);
|
let d=edge_n.dot(diff);
|
||||||
|
if zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
|
||||||
//test the edge
|
//test the edge
|
||||||
let edge_nn=edge_n.dot(edge_n);
|
let edge_nn=edge_n.dot(edge_n);
|
||||||
if !d.is_negative()&&d<=edge_nn{
|
if Planar64::ZERO<=d&&d<=edge_nn{
|
||||||
let distance_squared={
|
let distance_squared={
|
||||||
let c=diff.cross(edge_n);
|
let c=diff.cross(edge_n);
|
||||||
(c.dot(c)/edge_nn).divide().fix_2()
|
c.dot(c)/edge_nn
|
||||||
};
|
};
|
||||||
if distance_squared<=*best_distance_squared{
|
if distance_squared<=*best_distance_squared{
|
||||||
best_transition=EV::Edge(directed_edge_id.as_undirected());
|
best_transition=EV::Edge(directed_edge_id.as_undirected());
|
||||||
@ -691,7 +680,7 @@ impl MinkowskiMesh<'_>{
|
|||||||
let boundary_d=boundary_n.dot(delta_pos);
|
let boundary_d=boundary_n.dot(delta_pos);
|
||||||
//check if time of collision is outside Time::MIN..Time::MAX
|
//check if time of collision is outside Time::MIN..Time::MAX
|
||||||
//infinity_dir can always be treated as a velocity
|
//infinity_dir can always be treated as a velocity
|
||||||
if !boundary_d.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
|
if (boundary_d)<=Planar64::ZERO&&zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
|
||||||
//both faces cannot pass this condition, return early if one does.
|
//both faces cannot pass this condition, return early if one does.
|
||||||
return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
|
return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
|
||||||
}
|
}
|
||||||
@ -705,16 +694,15 @@ impl MinkowskiMesh<'_>{
|
|||||||
let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
|
let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
|
||||||
//a line is simpler to solve than a parabola
|
//a line is simpler to solve than a parabola
|
||||||
infinity_body.velocity=dir;
|
infinity_body.velocity=dir;
|
||||||
infinity_body.acceleration=vec3::ZERO;
|
infinity_body.acceleration=Planar64Vec3::ZERO;
|
||||||
//crawl in from negative infinity along a tangent line to get the closest fev
|
//crawl in from negative infinity along a tangent line to get the closest fev
|
||||||
// TODO: change crawl_fev args to delta time? Optional values?
|
match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN,infinity_body.time){
|
||||||
match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
|
|
||||||
crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
|
crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
|
||||||
crate::face_crawler::CrawlResult::Hit(_,_)=>None,
|
crate::face_crawler::CrawlResult::Hit(_,_)=>None,
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
|
pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
|
||||||
self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
|
self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
|
||||||
//continue forwards along the body parabola
|
//continue forwards along the body parabola
|
||||||
match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
|
match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
|
||||||
@ -723,7 +711,7 @@ impl MinkowskiMesh<'_>{
|
|||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
|
pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
|
||||||
//create an extrapolated body at time_limit
|
//create an extrapolated body at time_limit
|
||||||
let infinity_body=crate::physics::Body::new(
|
let infinity_body=crate::physics::Body::new(
|
||||||
relative_body.extrapolated_position(time_limit),
|
relative_body.extrapolated_position(time_limit),
|
||||||
@ -739,13 +727,10 @@ impl MinkowskiMesh<'_>{
|
|||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
|
pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,integer::Time)>{
|
||||||
//no algorithm needed, there is only one state and two cases (Edge,None)
|
//no algorithm needed, there is only one state and two cases (Edge,None)
|
||||||
//determine when it passes an edge ("sliding off" case)
|
//determine when it passes an edge ("sliding off" case)
|
||||||
let mut best_time={
|
let mut best_time=time_limit;
|
||||||
let r=(time_limit-relative_body.time).to_ratio();
|
|
||||||
Ratio::new(r.num.fix_4(),r.den.fix_4())
|
|
||||||
};
|
|
||||||
let mut best_edge=None;
|
let mut best_edge=None;
|
||||||
let face_n=self.face_nd(contact_face_id).0;
|
let face_n=self.face_nd(contact_face_id).0;
|
||||||
for &directed_edge_id in self.face_edges(contact_face_id).iter(){
|
for &directed_edge_id in self.face_edges(contact_face_id).iter(){
|
||||||
@ -755,10 +740,10 @@ impl MinkowskiMesh<'_>{
|
|||||||
let verts=self.edge_verts(directed_edge_id.as_undirected());
|
let verts=self.edge_verts(directed_edge_id.as_undirected());
|
||||||
let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
|
let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
|
||||||
//WARNING! d outside of *2
|
//WARNING! d outside of *2
|
||||||
//WARNING: truncated precision
|
for t in zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
|
||||||
for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).fix_4(),n.dot(relative_body.velocity).fix_4()*2,n.dot(relative_body.acceleration).fix_4()){
|
let t=relative_body.time+integer::Time::from(t);
|
||||||
if Ratio::new(Planar64::ZERO,Planar64::EPSILON).le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
|
if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=dt;
|
best_time=t;
|
||||||
best_edge=Some(directed_edge_id);
|
best_edge=Some(directed_edge_id);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -766,28 +751,9 @@ impl MinkowskiMesh<'_>{
|
|||||||
}
|
}
|
||||||
best_edge.map(|e|(e.as_undirected(),best_time))
|
best_edge.map(|e|(e.as_undirected(),best_time))
|
||||||
}
|
}
|
||||||
fn infinity_in(&self,infinity_body:crate::physics::Body)->Option<(MinkowskiFace,GigaTime)>{
|
|
||||||
let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
|
|
||||||
match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
|
|
||||||
crate::face_crawler::CrawlResult::Miss(_)=>None,
|
|
||||||
crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
|
|
||||||
let infinity_body=crate::physics::Body::new(point,vec3::Y,vec3::ZERO,integer::Time::ZERO);
|
|
||||||
//movement must escape the mesh forwards and backwards in time,
|
|
||||||
//otherwise the point is not inside the mesh
|
|
||||||
self.infinity_in(infinity_body)
|
|
||||||
.is_some_and(|_|
|
|
||||||
self.infinity_in(-infinity_body)
|
|
||||||
.is_some()
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
|
impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
|
||||||
type Normal=Vector3<Fixed<3,96>>;
|
fn face_nd(&self,face_id:MinkowskiFace)->(Planar64Vec3,Planar64){
|
||||||
type Offset=Fixed<4,128>;
|
|
||||||
fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
|
|
||||||
match face_id{
|
match face_id{
|
||||||
MinkowskiFace::VertFace(v0,f1)=>{
|
MinkowskiFace::VertFace(v0,f1)=>{
|
||||||
let (n,d)=self.mesh1.face_nd(f1);
|
let (n,d)=self.mesh1.face_nd(f1);
|
||||||
@ -801,7 +767,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
|
|||||||
let n=edge0_n.cross(edge1_n);
|
let n=edge0_n.cross(edge1_n);
|
||||||
let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
|
let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
|
||||||
let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
|
let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
|
||||||
((n*(parity as i64*4-2)).fix_3(),((e0d-e1d)*(parity as i64*2-1)).fix_4())
|
(n*(parity as i64*4-2),(e0d-e1d)*(parity as i64*2-1))
|
||||||
},
|
},
|
||||||
MinkowskiFace::FaceVert(f0,v1)=>{
|
MinkowskiFace::FaceVert(f0,v1)=>{
|
||||||
let (n,d)=self.mesh0.face_nd(f0);
|
let (n,d)=self.mesh0.face_nd(f0);
|
||||||
@ -850,18 +816,17 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
|
|||||||
let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).borrow();
|
let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).borrow();
|
||||||
Cow::Owned([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
|
Cow::Owned([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
|
||||||
let mut best_edge=None;
|
let mut best_edge=None;
|
||||||
let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
|
let mut best_d=Planar64::ZERO;
|
||||||
let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
|
let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
|
||||||
let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
|
let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
|
||||||
for &directed_edge_id0 in v0e.iter(){
|
for &directed_edge_id0 in v0e.iter(){
|
||||||
let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
|
let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
|
||||||
//must be behind other face.
|
//must be behind other face.
|
||||||
let d=edge_face1_n.dot(edge0_n);
|
let d=edge_face1_n.dot(edge0_n);
|
||||||
if d.is_negative(){
|
if d<Planar64::ZERO{
|
||||||
let edge0_nn=edge0_n.dot(edge0_n);
|
let edge0_nn=edge0_n.dot(edge0_n);
|
||||||
// Assume not every number is huge
|
//divide by zero???
|
||||||
// TODO: revisit this
|
let dd=d*d/(edge_face1_nn*edge0_nn);
|
||||||
let dd=(d*d)/(edge_face1_nn*edge0_nn);
|
|
||||||
if best_d<dd{
|
if best_d<dd{
|
||||||
best_d=dd;
|
best_d=dd;
|
||||||
best_edge=Some(directed_edge_id0);
|
best_edge=Some(directed_edge_id0);
|
||||||
@ -880,15 +845,15 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
|
|||||||
let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).borrow();
|
let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).borrow();
|
||||||
Cow::Owned([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
|
Cow::Owned([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
|
||||||
let mut best_edge=None;
|
let mut best_edge=None;
|
||||||
let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
|
let mut best_d=Planar64::ZERO;
|
||||||
let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
|
let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
|
||||||
let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
|
let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
|
||||||
for &directed_edge_id1 in v1e.iter(){
|
for &directed_edge_id1 in v1e.iter(){
|
||||||
let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
|
let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
|
||||||
let d=edge_face0_n.dot(edge1_n);
|
let d=edge_face0_n.dot(edge1_n);
|
||||||
if d.is_negative(){
|
if d<Planar64::ZERO{
|
||||||
let edge1_nn=edge1_n.dot(edge1_n);
|
let edge1_nn=edge1_n.dot(edge1_n);
|
||||||
let dd=(d*d)/(edge_face0_nn*edge1_nn);
|
let dd=d*d/(edge_face0_nn*edge1_nn);
|
||||||
if best_d<dd{
|
if best_d<dd{
|
||||||
best_d=dd;
|
best_d=dd;
|
||||||
best_edge=Some(directed_edge_id1);
|
best_edge=Some(directed_edge_id1);
|
||||||
@ -924,20 +889,19 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
|
|||||||
//detect shared volume when the other mesh is mirrored along a test edge dir
|
//detect shared volume when the other mesh is mirrored along a test edge dir
|
||||||
let v0f=self.mesh0.vert_faces(v0);
|
let v0f=self.mesh0.vert_faces(v0);
|
||||||
let v1f=self.mesh1.vert_faces(v1);
|
let v1f=self.mesh1.vert_faces(v1);
|
||||||
let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
|
let v0f_n:Vec<Planar64Vec3>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
|
||||||
let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
|
let v1f_n:Vec<Planar64Vec3>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
|
||||||
let the_len=v0f.len()+v1f.len();
|
let the_len=v0f.len()+v1f.len();
|
||||||
for &directed_edge_id in self.mesh0.vert_edges(v0).iter(){
|
for &directed_edge_id in self.mesh0.vert_edges(v0).iter(){
|
||||||
let n=self.mesh0.directed_edge_n(directed_edge_id);
|
let n=self.mesh0.directed_edge_n(directed_edge_id);
|
||||||
let nn=n.dot(n);
|
let nn=n.dot(n);
|
||||||
// TODO: there's gotta be a better way to do this
|
|
||||||
//make a set of faces
|
//make a set of faces
|
||||||
let mut face_normals=Vec::with_capacity(the_len);
|
let mut face_normals=Vec::with_capacity(the_len);
|
||||||
//add mesh0 faces as-is
|
//add mesh0 faces as-is
|
||||||
face_normals.clone_from(&v0f_n);
|
face_normals.clone_from(&v0f_n);
|
||||||
for face_n in &v1f_n{
|
for face_n in &v1f_n{
|
||||||
//add reflected mesh1 faces
|
//add reflected mesh1 faces
|
||||||
face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().fix_3());
|
face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
|
||||||
}
|
}
|
||||||
if is_empty_volume(face_normals){
|
if is_empty_volume(face_normals){
|
||||||
edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
|
edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
|
||||||
@ -949,7 +913,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
|
|||||||
let mut face_normals=Vec::with_capacity(the_len);
|
let mut face_normals=Vec::with_capacity(the_len);
|
||||||
face_normals.clone_from(&v1f_n);
|
face_normals.clone_from(&v1f_n);
|
||||||
for face_n in &v0f_n{
|
for face_n in &v0f_n{
|
||||||
face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().fix_3());
|
face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
|
||||||
}
|
}
|
||||||
if is_empty_volume(face_normals){
|
if is_empty_volume(face_normals){
|
||||||
edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
|
edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
|
||||||
@ -964,7 +928,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
|
fn is_empty_volume(normals:Vec<Planar64Vec3>)->bool{
|
||||||
let len=normals.len();
|
let len=normals.len();
|
||||||
for i in 0..len-1{
|
for i in 0..len-1{
|
||||||
for j in i+1..len{
|
for j in i+1..len{
|
||||||
@ -972,10 +936,9 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
|
|||||||
let mut d_comp=None;
|
let mut d_comp=None;
|
||||||
for k in 0..len{
|
for k in 0..len{
|
||||||
if k!=i&&k!=j{
|
if k!=i&&k!=j{
|
||||||
let d=n.dot(normals[k]).is_negative();
|
let d=n.dot(normals[k]);
|
||||||
if let Some(comp)=&d_comp{
|
if let Some(comp)=&d_comp{
|
||||||
// This is testing if d_comp*d < 0
|
if *comp*d<Planar64::ZERO{
|
||||||
if comp^d{
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}else{
|
}else{
|
||||||
@ -990,8 +953,8 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
|
|||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_is_empty_volume(){
|
fn test_is_empty_volume(){
|
||||||
assert!(!is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3()].to_vec()));
|
assert!(!is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z].to_vec()));
|
||||||
assert!(is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3(),vec3::NEG_X.fix_3()].to_vec()));
|
assert!(is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z,Planar64Vec3::NEG_X].to_vec()));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
1470
src/physics.rs
1470
src/physics.rs
File diff suppressed because it is too large
Load Diff
@ -1,10 +1,6 @@
|
|||||||
use strafesnet_common::mouse::MouseState;
|
use crate::physics::{MouseState,PhysicsInputInstruction};
|
||||||
use strafesnet_common::physics::Instruction as PhysicsInputInstruction;
|
|
||||||
use strafesnet_common::integer::Time;
|
use strafesnet_common::integer::Time;
|
||||||
use strafesnet_common::instruction::TimedInstruction;
|
use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
|
||||||
use strafesnet_common::timer::{Scaled,Timer,TimerState};
|
|
||||||
use mouse_interpolator::MouseInterpolator;
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum InputInstruction{
|
pub enum InputInstruction{
|
||||||
MoveMouse(glam::IVec2),
|
MoveMouse(glam::IVec2),
|
||||||
@ -16,227 +12,194 @@ pub enum InputInstruction{
|
|||||||
MoveForward(bool),
|
MoveForward(bool),
|
||||||
Jump(bool),
|
Jump(bool),
|
||||||
Zoom(bool),
|
Zoom(bool),
|
||||||
ResetAndRestart,
|
Reset,
|
||||||
ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
|
|
||||||
PracticeFly,
|
PracticeFly,
|
||||||
}
|
}
|
||||||
pub enum Instruction{
|
pub enum Instruction{
|
||||||
Input(InputInstruction),
|
Passthrough(PassthroughInstruction),
|
||||||
|
Interpolate(InputInstruction),
|
||||||
|
}
|
||||||
|
pub enum PassthroughInstruction{
|
||||||
Render,
|
Render,
|
||||||
Resize(winit::dpi::PhysicalSize<u32>),
|
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
|
||||||
ChangeMap(strafesnet_common::map::CompleteMap),
|
GenerateModels(strafesnet_common::map::CompleteMap),
|
||||||
//SetPaused is not an InputInstruction: the physics doesn't know that it's paused.
|
ClearModels,
|
||||||
SetPaused(bool),
|
|
||||||
//Graphics(crate::graphics_worker::Instruction),
|
//Graphics(crate::graphics_worker::Instruction),
|
||||||
}
|
}
|
||||||
mod mouse_interpolator{
|
|
||||||
use super::*;
|
|
||||||
//TODO: move this or tab
|
|
||||||
pub struct MouseInterpolator{
|
pub struct MouseInterpolator{
|
||||||
//"PlayerController"
|
queue:std::collections::VecDeque<TimedInstruction<InputInstruction>>,
|
||||||
user_settings:crate::settings::UserSettings,
|
}
|
||||||
//"MouseInterpolator"
|
fn drain_queue(physics:&mut crate::physics::PhysicsContext,iterable:impl IntoIterator<Item=TimedInstruction<InputInstruction>>){
|
||||||
timeline:std::collections::VecDeque<TimedInstruction<PhysicsInputInstruction>>,
|
for ins in iterable{
|
||||||
last_mouse_time:Time,//this value is pre-transformed to simulation time
|
let physics_input=match &ins.instruction{
|
||||||
mouse_blocking:bool,
|
InputInstruction::MoveMouse(_)=>panic!("Queue was confirmed to contain no MoveMouse events1"),
|
||||||
//"Simulation"
|
&InputInstruction::MoveForward(s)=>PhysicsInputInstruction::SetMoveForward(s),
|
||||||
timer:Timer<Scaled>,
|
&InputInstruction::MoveLeft(s)=>PhysicsInputInstruction::SetMoveLeft(s),
|
||||||
physics:crate::physics::PhysicsContext,
|
&InputInstruction::MoveBack(s)=>PhysicsInputInstruction::SetMoveBack(s),
|
||||||
|
&InputInstruction::MoveRight(s)=>PhysicsInputInstruction::SetMoveRight(s),
|
||||||
|
&InputInstruction::MoveUp(s)=>PhysicsInputInstruction::SetMoveUp(s),
|
||||||
|
&InputInstruction::MoveDown(s)=>PhysicsInputInstruction::SetMoveDown(s),
|
||||||
|
&InputInstruction::Jump(s)=>PhysicsInputInstruction::SetJump(s),
|
||||||
|
&InputInstruction::Zoom(s)=>PhysicsInputInstruction::SetZoom(s),
|
||||||
|
InputInstruction::Reset=>PhysicsInputInstruction::Reset,
|
||||||
|
InputInstruction::PracticeFly=>PhysicsInputInstruction::PracticeFly,
|
||||||
|
};
|
||||||
|
physics.run_input_instruction(TimedInstruction{
|
||||||
|
time:ins.time,
|
||||||
|
instruction:physics_input,
|
||||||
|
});
|
||||||
|
}
|
||||||
}
|
}
|
||||||
impl MouseInterpolator{
|
impl MouseInterpolator{
|
||||||
pub fn new(
|
fn handle_instruction(&mut self,physics:&mut crate::physics::PhysicsContext,ins:TimedInstruction<InputInstruction>){
|
||||||
physics:crate::physics::PhysicsContext,
|
//need to handle the case where mouse polling rate is less than 100hz
|
||||||
user_settings:crate::settings::UserSettings,
|
//also the whole thing is probably wrong lol
|
||||||
)->MouseInterpolator{
|
let is_inserting_mouse_instruction=matches!(ins.instruction,InputInstruction::MoveMouse(_));
|
||||||
MouseInterpolator{
|
self.queue.push_back(ins);
|
||||||
mouse_blocking:true,
|
//We just pushed an element.
|
||||||
last_mouse_time:physics.get_next_mouse().time,
|
//The first element is guaranteed to exist.
|
||||||
timeline:std::collections::VecDeque::new(),
|
let mut iter=self.queue.iter();
|
||||||
timer:Timer::from_state(Scaled::identity(),false),
|
//find a mouse input
|
||||||
physics,
|
'outer:loop{
|
||||||
user_settings,
|
match iter.next(){
|
||||||
}
|
Some(ins0)=>{
|
||||||
}
|
let physics_input=match &ins0.instruction{
|
||||||
fn push_mouse_instruction(&mut self,ins:&TimedInstruction<Instruction>,m:glam::IVec2){
|
&InputInstruction::MoveMouse(mut mouse0)=>{
|
||||||
if self.mouse_blocking{
|
//mouse instruction found.
|
||||||
//tell the game state which is living in the past about its future
|
//enter a new loop with different behaviour
|
||||||
self.timeline.push_front(TimedInstruction{
|
//we have to wait for the next mouse event
|
||||||
time:self.last_mouse_time,
|
//so there is a before and after interpolation target
|
||||||
instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(ins.time),pos:m}),
|
//write down ins0.time to appease the borrow checker
|
||||||
});
|
let mut t0=ins0.time;
|
||||||
}else{
|
'inner:loop{
|
||||||
//mouse has just started moving again after being still for longer than 10ms.
|
match iter.next(){
|
||||||
//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
|
Some(ins1)=>match &ins1.instruction{
|
||||||
self.timeline.push_front(TimedInstruction{
|
&InputInstruction::MoveMouse(mouse1)=>{
|
||||||
time:self.last_mouse_time,
|
//we found two mouse events to interpolate between
|
||||||
instruction:PhysicsInputInstruction::ReplaceMouse(
|
let consume_count=self.queue.len()-iter.len()-1;//don't consume the mouse1 instruction
|
||||||
MouseState{time:self.last_mouse_time,pos:self.physics.get_next_mouse().pos},
|
//fire off a mouse instruction
|
||||||
MouseState{time:self.timer.time(ins.time),pos:m}
|
physics.run_input_instruction(TimedInstruction{
|
||||||
|
time:t0,
|
||||||
|
instruction:PhysicsInputInstruction::SetNextMouse(
|
||||||
|
MouseState{time:ins1.time,pos:mouse1}
|
||||||
),
|
),
|
||||||
});
|
});
|
||||||
//delay physics execution until we have an interpolation target
|
//update inner loop state
|
||||||
self.mouse_blocking=true;
|
mouse0=mouse1;
|
||||||
}
|
t0=ins1.time;
|
||||||
self.last_mouse_time=self.timer.time(ins.time);
|
//drain and handle the elements from the front
|
||||||
}
|
std::mem::drop(iter);
|
||||||
fn push(&mut self,time:Time,phys_input:PhysicsInputInstruction){
|
let mut hot_queue=self.queue.drain(0..consume_count);
|
||||||
//This is always a non-mouse event
|
hot_queue.next();
|
||||||
self.timeline.push_back(TimedInstruction{
|
drain_queue(physics,hot_queue);
|
||||||
time:self.timer.time(time),
|
iter=self.queue.iter();
|
||||||
instruction:phys_input,
|
//keep looking for another mouse instruction in the inner loop
|
||||||
|
continue 'inner;
|
||||||
|
},
|
||||||
|
_=>if Time::from_millis(10)<ins1.time-t0{
|
||||||
|
//we have passed more than 10ms of instructions and have not seen a mouse event.
|
||||||
|
let consume_count=self.queue.len()-iter.len();
|
||||||
|
//run an event to extrapolate no movement from
|
||||||
|
let last_mouse=physics.get_next_mouse();
|
||||||
|
physics.run_input_instruction(TimedInstruction{
|
||||||
|
time:last_mouse.time,
|
||||||
|
instruction:PhysicsInputInstruction::SetNextMouse(
|
||||||
|
MouseState{time:ins1.time,pos:last_mouse.pos}
|
||||||
|
),
|
||||||
|
});
|
||||||
|
//drop the iterator so we can consume the queue up to this point
|
||||||
|
std::mem::drop(iter);
|
||||||
|
//consume queue up to the scanned point
|
||||||
|
let mut hot_queue=self.queue.drain(0..consume_count);
|
||||||
|
//the first element is always the last mouse instruction (last_mouse above)
|
||||||
|
hot_queue.next();
|
||||||
|
drain_queue(physics,hot_queue);
|
||||||
|
//make a new iterator starting from the new beginning
|
||||||
|
//and continue looping like nothing happened
|
||||||
|
iter=self.queue.iter();
|
||||||
|
continue 'outer;
|
||||||
|
},
|
||||||
|
},
|
||||||
|
None=>{
|
||||||
|
if is_inserting_mouse_instruction{
|
||||||
|
//the mouse started moving again after being still for over 10ms.
|
||||||
|
//replace the entire mouse state
|
||||||
|
physics.run_input_instruction(TimedInstruction{
|
||||||
|
time:physics.get_next_mouse().time,
|
||||||
|
instruction:PhysicsInputInstruction::ReplaceMouse(
|
||||||
|
physics.get_next_mouse().clone(),
|
||||||
|
MouseState{time:t0,pos:mouse0}
|
||||||
|
),
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
/// returns should_empty_queue
|
break 'outer;
|
||||||
/// may or may not mutate internal state XD!
|
|
||||||
fn map_instruction(&mut self,ins:&TimedInstruction<Instruction>)->bool{
|
|
||||||
let mut update_mouse_blocking=true;
|
|
||||||
match &ins.instruction{
|
|
||||||
Instruction::Input(input_instruction)=>match input_instruction{
|
|
||||||
&InputInstruction::MoveMouse(m)=>{
|
|
||||||
if !self.timer.is_paused(){
|
|
||||||
self.push_mouse_instruction(ins,m);
|
|
||||||
}
|
|
||||||
update_mouse_blocking=false;
|
|
||||||
},
|
|
||||||
&InputInstruction::MoveForward(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveForward(s)),
|
|
||||||
&InputInstruction::MoveLeft(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveLeft(s)),
|
|
||||||
&InputInstruction::MoveBack(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveBack(s)),
|
|
||||||
&InputInstruction::MoveRight(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveRight(s)),
|
|
||||||
&InputInstruction::MoveUp(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveUp(s)),
|
|
||||||
&InputInstruction::MoveDown(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveDown(s)),
|
|
||||||
&InputInstruction::Jump(s)=>self.push(ins.time,PhysicsInputInstruction::SetJump(s)),
|
|
||||||
&InputInstruction::Zoom(s)=>self.push(ins.time,PhysicsInputInstruction::SetZoom(s)),
|
|
||||||
&InputInstruction::ResetAndSpawn(mode_id,stage_id)=>{
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::Reset);
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::Spawn(mode_id,stage_id));
|
|
||||||
},
|
|
||||||
InputInstruction::ResetAndRestart=>{
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::Reset);
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::Restart);
|
|
||||||
},
|
|
||||||
InputInstruction::PracticeFly=>self.push(ins.time,PhysicsInputInstruction::PracticeFly),
|
|
||||||
},
|
|
||||||
//do these really need to idle the physics?
|
|
||||||
//sending None dumps the instruction queue
|
|
||||||
Instruction::ChangeMap(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
|
|
||||||
Instruction::Resize(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
|
|
||||||
Instruction::Render=>self.push(ins.time,PhysicsInputInstruction::Idle),
|
|
||||||
&Instruction::SetPaused(paused)=>{
|
|
||||||
if let Err(e)=self.timer.set_paused(ins.time,paused){
|
|
||||||
println!("Cannot pause: {e}");
|
|
||||||
}
|
|
||||||
self.push(ins.time,PhysicsInputInstruction::Idle);
|
|
||||||
},
|
|
||||||
}
|
|
||||||
if update_mouse_blocking{
|
|
||||||
//this returns the bool for us
|
|
||||||
self.update_mouse_blocking(ins.time)
|
|
||||||
}else{
|
|
||||||
//do flush that queue
|
|
||||||
true
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
/// must check if self.mouse_blocking==true before calling!
|
}
|
||||||
fn unblock_mouse(&mut self,time:Time){
|
},
|
||||||
//push an event to extrapolate no movement from
|
&InputInstruction::MoveForward(s)=>PhysicsInputInstruction::SetMoveForward(s),
|
||||||
self.timeline.push_front(TimedInstruction{
|
&InputInstruction::MoveLeft(s)=>PhysicsInputInstruction::SetMoveLeft(s),
|
||||||
time:self.last_mouse_time,
|
&InputInstruction::MoveBack(s)=>PhysicsInputInstruction::SetMoveBack(s),
|
||||||
instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(time),pos:self.physics.get_next_mouse().pos}),
|
&InputInstruction::MoveRight(s)=>PhysicsInputInstruction::SetMoveRight(s),
|
||||||
|
&InputInstruction::MoveUp(s)=>PhysicsInputInstruction::SetMoveUp(s),
|
||||||
|
&InputInstruction::MoveDown(s)=>PhysicsInputInstruction::SetMoveDown(s),
|
||||||
|
&InputInstruction::Jump(s)=>PhysicsInputInstruction::SetJump(s),
|
||||||
|
&InputInstruction::Zoom(s)=>PhysicsInputInstruction::SetZoom(s),
|
||||||
|
InputInstruction::Reset=>PhysicsInputInstruction::Reset,
|
||||||
|
InputInstruction::PracticeFly=>PhysicsInputInstruction::PracticeFly,
|
||||||
|
};
|
||||||
|
//handle each event immediately, we are not waiting for mouse
|
||||||
|
physics.run_input_instruction(TimedInstruction{
|
||||||
|
time:ins0.time,
|
||||||
|
instruction:physics_input,
|
||||||
});
|
});
|
||||||
self.last_mouse_time=self.timer.time(time);
|
//drop it and pop it! consume one element and continue the loop
|
||||||
//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
|
std::mem::drop(iter);
|
||||||
self.mouse_blocking=false;
|
self.queue.pop_front();
|
||||||
}
|
iter=self.queue.iter();
|
||||||
fn update_mouse_blocking(&mut self,time:Time)->bool{
|
},
|
||||||
if self.mouse_blocking{
|
None=>{
|
||||||
//assume the mouse has stopped moving after 10ms.
|
//if mouse0 is never found and the loop ends, we can drain the entire queue
|
||||||
//shitty mice are 125Hz which is 8ms so this should cover that.
|
//because we are not waiting for mouse events.
|
||||||
//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
|
drain_queue(physics,self.queue.drain(..));
|
||||||
//so mouse events are probably not handled separately from drawing and fire right before it :(
|
break 'outer;
|
||||||
if Time::from_millis(10)<self.timer.time(time)-self.physics.get_next_mouse().time{
|
|
||||||
self.unblock_mouse(time);
|
|
||||||
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
|
|
||||||
self.last_mouse_time=self.timer.time(time);
|
|
||||||
true
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn empty_queue(&mut self){
|
|
||||||
while let Some(instruction)=self.timeline.pop_front(){
|
|
||||||
self.physics.run_input_instruction(instruction);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn handle_instruction(&mut self,ins:&TimedInstruction<Instruction>){
|
|
||||||
let should_empty_queue=self.map_instruction(ins);
|
|
||||||
if should_empty_queue{
|
|
||||||
self.empty_queue();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn get_frame_state(&self,time:Time)->crate::graphics::FrameState{
|
|
||||||
crate::graphics::FrameState{
|
|
||||||
body:self.physics.camera_body(),
|
|
||||||
camera:self.physics.camera(),
|
|
||||||
time:self.timer.time(time),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn change_map(&mut self,time:Time,map:&strafesnet_common::map::CompleteMap){
|
|
||||||
//dump any pending interpolation state
|
|
||||||
if self.mouse_blocking{
|
|
||||||
self.unblock_mouse(time);
|
|
||||||
}
|
|
||||||
self.empty_queue();
|
|
||||||
|
|
||||||
//doing it like this to avoid doing PhysicsInstruction::ChangeMap(Rc<CompleteMap>)
|
|
||||||
self.physics.generate_models(&map);
|
|
||||||
|
|
||||||
//use the standard input interface so the instructions are written out to bots
|
|
||||||
self.handle_instruction(&TimedInstruction{
|
|
||||||
time:self.timer.time(time),
|
|
||||||
instruction:Instruction::Input(InputInstruction::ResetAndSpawn(
|
|
||||||
strafesnet_common::gameplay_modes::ModeId::MAIN,
|
|
||||||
strafesnet_common::gameplay_modes::StageId::FIRST,
|
|
||||||
)),
|
|
||||||
});
|
|
||||||
}
|
|
||||||
pub const fn user_settings(&self)->&crate::settings::UserSettings{
|
|
||||||
&self.user_settings
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn new<'a>(
|
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>>{
|
||||||
mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
|
let mut interpolator=MouseInterpolator{
|
||||||
user_settings:crate::settings::UserSettings,
|
queue:std::collections::VecDeque::new(),
|
||||||
)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction>>{
|
};
|
||||||
let physics=crate::physics::PhysicsContext::default();
|
|
||||||
let mut interpolator=MouseInterpolator::new(
|
|
||||||
physics,
|
|
||||||
user_settings
|
|
||||||
);
|
|
||||||
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
|
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
|
||||||
interpolator.handle_instruction(&ins);
|
let passthrough_instruction=match ins.instruction{
|
||||||
match ins.instruction{
|
Instruction::Passthrough(passthrough_instruction)=>passthrough_instruction,
|
||||||
Instruction::Render=>{
|
Instruction::Interpolate(input_instruction)=>{
|
||||||
let frame_state=interpolator.get_frame_state(ins.time);
|
interpolator.handle_instruction(&mut physics,TimedInstruction{
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::Render(frame_state)).unwrap();
|
instruction:input_instruction,
|
||||||
|
time:ins.time,
|
||||||
|
});
|
||||||
|
return;
|
||||||
},
|
},
|
||||||
Instruction::Resize(size)=>{
|
};
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,interpolator.user_settings().clone())).unwrap();
|
match passthrough_instruction{
|
||||||
|
PassthroughInstruction::Render=>{
|
||||||
|
graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.get_next_mouse().pos)).unwrap();
|
||||||
},
|
},
|
||||||
Instruction::ChangeMap(map)=>{
|
PassthroughInstruction::Resize(size,user_settings)=>{
|
||||||
interpolator.change_map(ins.time,&map);
|
graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::ChangeMap(map)).unwrap();
|
},
|
||||||
|
PassthroughInstruction::GenerateModels(map)=>{
|
||||||
|
physics.generate_models(&map);
|
||||||
|
physics.spawn();
|
||||||
|
graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(map)).unwrap();
|
||||||
|
},
|
||||||
|
PassthroughInstruction::ClearModels=>{
|
||||||
|
physics.clear();
|
||||||
|
graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
|
||||||
},
|
},
|
||||||
Instruction::Input(_)=>(),
|
|
||||||
Instruction::SetPaused(_)=>(),
|
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
11
src/setup.rs
11
src/setup.rs
@ -213,14 +213,13 @@ pub fn setup_and_start(title:String){
|
|||||||
|
|
||||||
//dedicated thread to ping request redraw back and resize the window doesn't seem logical
|
//dedicated thread to ping request redraw back and resize the window doesn't seem logical
|
||||||
|
|
||||||
|
let window=crate::window::WindowContextSetup::new(&setup_context,&window);
|
||||||
//the thread that spawns the physics thread
|
//the thread that spawns the physics thread
|
||||||
let mut window_thread=crate::window::worker(
|
let mut window_thread=window.into_worker(setup_context);
|
||||||
&window,
|
|
||||||
setup_context,
|
|
||||||
);
|
|
||||||
|
|
||||||
if let Some(arg)=std::env::args().nth(1){
|
let args:Vec<String>=std::env::args().collect();
|
||||||
let path=std::path::PathBuf::from(arg);
|
if args.len()==2{
|
||||||
|
let path=std::path::PathBuf::from(&args[1]);
|
||||||
window_thread.send(TimedInstruction{
|
window_thread.send(TimedInstruction{
|
||||||
time:integer::Time::ZERO,
|
time:integer::Time::ZERO,
|
||||||
instruction:WindowInstruction::WindowEvent(winit::event::WindowEvent::DroppedFile(path)),
|
instruction:WindowInstruction::WindowEvent(winit::event::WindowEvent::DroppedFile(path)),
|
||||||
|
179
src/timer.rs
Normal file
179
src/timer.rs
Normal file
@ -0,0 +1,179 @@
|
|||||||
|
use strafesnet_common::integer::{Time,Ratio64};
|
||||||
|
|
||||||
|
pub trait TimerState:Copy{
|
||||||
|
fn get_time(&self,time:Time)->Time;
|
||||||
|
fn set_time(&mut self,time:Time,new_time:Time);
|
||||||
|
fn get_offset(&self)->Time;
|
||||||
|
fn set_offset(&mut self,offset:Time);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone,Copy,Debug)]
|
||||||
|
struct Scaled{
|
||||||
|
scale:Ratio64,
|
||||||
|
offset:Time,
|
||||||
|
}
|
||||||
|
impl Scaled{
|
||||||
|
fn scale(&self,time:Time)->Time{
|
||||||
|
Time::raw(self.scale.mul_int(time.get()))
|
||||||
|
}
|
||||||
|
fn get_scale(&self)->Ratio64{
|
||||||
|
self.scale
|
||||||
|
}
|
||||||
|
fn set_scale(&mut self,time:Time,new_scale:Ratio64){
|
||||||
|
let new_time=self.get_time(time);
|
||||||
|
self.scale=new_scale;
|
||||||
|
self.set_time(time,new_time);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TimerState for Scaled{
|
||||||
|
fn get_time(&self,time:Time)->Time{
|
||||||
|
self.scale(time)+self.offset
|
||||||
|
}
|
||||||
|
fn set_time(&mut self,time:Time,new_time:Time){
|
||||||
|
self.offset=new_time-self.scale(time);
|
||||||
|
}
|
||||||
|
fn get_offset(&self)->Time{
|
||||||
|
self.offset
|
||||||
|
}
|
||||||
|
fn set_offset(&mut self,offset:Time){
|
||||||
|
self.offset=offset;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone,Copy,Debug)]
|
||||||
|
struct Realtime{
|
||||||
|
offset:Time,
|
||||||
|
}
|
||||||
|
impl TimerState for Realtime{
|
||||||
|
fn get_time(&self,time:Time)->Time{
|
||||||
|
time+self.offset
|
||||||
|
}
|
||||||
|
fn set_time(&mut self,time:Time,new_time:Time){
|
||||||
|
self.offset=new_time-time;
|
||||||
|
}
|
||||||
|
fn get_offset(&self)->Time{
|
||||||
|
self.offset
|
||||||
|
}
|
||||||
|
fn set_offset(&mut self,offset:Time){
|
||||||
|
self.offset=offset;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone,Debug)]
|
||||||
|
pub struct Timer<T>{
|
||||||
|
state:T,
|
||||||
|
paused:bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Timer<Realtime>{
|
||||||
|
pub fn realtime(offset:Time)->Self{
|
||||||
|
Self{
|
||||||
|
state:Realtime{offset},
|
||||||
|
paused:false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn realtime_paused(offset:Time)->Self{
|
||||||
|
Self{
|
||||||
|
state:Realtime{offset},
|
||||||
|
paused:true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Error{
|
||||||
|
AlreadyPaused,
|
||||||
|
AlreadyUnpaused,
|
||||||
|
}
|
||||||
|
impl std::fmt::Display for Error{
|
||||||
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
|
write!(f,"{self:?}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::error::Error for Error{}
|
||||||
|
|
||||||
|
impl Timer<Scaled>{
|
||||||
|
pub fn scaled(scale:Ratio64,offset:Time)->Self{
|
||||||
|
Self{
|
||||||
|
state:Scaled{scale,offset},
|
||||||
|
paused:false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn scaled_paused(scale:Ratio64,offset:Time)->Self{
|
||||||
|
Self{
|
||||||
|
state:Scaled{scale,offset},
|
||||||
|
paused:true,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn get_scale(&mut self)->Ratio64{
|
||||||
|
self.state.get_scale()
|
||||||
|
}
|
||||||
|
pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
|
||||||
|
self.state.set_scale(time,new_scale)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T:TimerState> Timer<T>{
|
||||||
|
pub fn time(&self,time:Time)->Time{
|
||||||
|
match self.paused{
|
||||||
|
true=>self.state.get_offset(),
|
||||||
|
false=>self.state.get_time(time),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn set_time(&mut self,time:Time,new_time:Time){
|
||||||
|
match self.paused{
|
||||||
|
true=>self.state.set_offset(new_time),
|
||||||
|
false=>self.state.set_time(time,new_time),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn pause(&mut self,time:Time)->Result<(),Error>{
|
||||||
|
match self.paused{
|
||||||
|
true=>Err(Error::AlreadyPaused),
|
||||||
|
false=>{
|
||||||
|
let new_time=self.time(time);
|
||||||
|
self.state.set_offset(new_time);
|
||||||
|
self.paused=true;
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn unpause(&mut self,time:Time)->Result<(),Error>{
|
||||||
|
match self.paused{
|
||||||
|
true=>{
|
||||||
|
let new_time=self.time(time);
|
||||||
|
self.state.set_time(time,new_time);
|
||||||
|
self.paused=false;
|
||||||
|
Ok(())
|
||||||
|
},
|
||||||
|
false=>Err(Error::AlreadyUnpaused),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test{
|
||||||
|
use super::{Time,Timer,Error};
|
||||||
|
macro_rules! sec {
|
||||||
|
($s: expr) => {
|
||||||
|
Time::from_secs($s)
|
||||||
|
};
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_timer()->Result<(),Error>{
|
||||||
|
//create a paused timer that reads 0s
|
||||||
|
let mut timer=Timer::realtime_paused(sec!(0));
|
||||||
|
//the paused timer at 1 second should read 0s
|
||||||
|
assert_eq!(timer.time(sec!(1)),sec!(0));
|
||||||
|
|
||||||
|
//unpause it after one second
|
||||||
|
timer.unpause(sec!(1))?;
|
||||||
|
//the timer at 6 seconds should read 5s
|
||||||
|
assert_eq!(timer.time(sec!(6)),sec!(5));
|
||||||
|
|
||||||
|
//pause the timer after 11 seconds
|
||||||
|
timer.pause(sec!(11))?;
|
||||||
|
//the paused timer at 20 seconds should read 10s
|
||||||
|
assert_eq!(timer.time(sec!(20)),sec!(10));
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
103
src/window.rs
103
src/window.rs
@ -13,8 +13,9 @@ pub enum WindowInstruction{
|
|||||||
//holds thread handles to dispatch to
|
//holds thread handles to dispatch to
|
||||||
struct WindowContext<'a>{
|
struct WindowContext<'a>{
|
||||||
manual_mouse_lock:bool,
|
manual_mouse_lock:bool,
|
||||||
mouse:strafesnet_common::mouse::MouseState,//std::sync::Arc<std::sync::Mutex<>>
|
mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
|
||||||
screen_size:glam::UVec2,
|
screen_size:glam::UVec2,
|
||||||
|
user_settings:crate::settings::UserSettings,
|
||||||
window:&'a winit::window::Window,
|
window:&'a winit::window::Window,
|
||||||
physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
|
physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
|
||||||
}
|
}
|
||||||
@ -27,16 +28,19 @@ impl WindowContext<'_>{
|
|||||||
match event {
|
match event {
|
||||||
winit::event::WindowEvent::DroppedFile(path)=>{
|
winit::event::WindowEvent::DroppedFile(path)=>{
|
||||||
match crate::file::load(path.as_path()){
|
match crate::file::load(path.as_path()){
|
||||||
Ok(map)=>self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ChangeMap(map)}).unwrap(),
|
Ok(map)=>{
|
||||||
|
self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::Passthrough(
|
||||||
|
crate::physics_worker::PassthroughInstruction::ClearModels
|
||||||
|
)}).unwrap();
|
||||||
|
self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::Passthrough(
|
||||||
|
crate::physics_worker::PassthroughInstruction::GenerateModels(map)
|
||||||
|
)}).unwrap();
|
||||||
|
},
|
||||||
Err(e)=>println!("Failed to load map: {e}"),
|
Err(e)=>println!("Failed to load map: {e}"),
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
winit::event::WindowEvent::Focused(state)=>{
|
winit::event::WindowEvent::Focused(_state)=>{
|
||||||
//pause unpause
|
//pause unpause
|
||||||
self.physics_thread.send(TimedInstruction{
|
|
||||||
time,
|
|
||||||
instruction:crate::physics_worker::Instruction::SetPaused(!state),
|
|
||||||
}).unwrap();
|
|
||||||
//recalculate pressed keys on focus
|
//recalculate pressed keys on focus
|
||||||
},
|
},
|
||||||
winit::event::WindowEvent::KeyboardInput{
|
winit::event::WindowEvent::KeyboardInput{
|
||||||
@ -100,26 +104,22 @@ impl WindowContext<'_>{
|
|||||||
if let Some(input_instruction)=match keycode{
|
if let Some(input_instruction)=match keycode{
|
||||||
winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
|
winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
|
||||||
winit::keyboard::Key::Character(key)=>match key.as_str(){
|
winit::keyboard::Key::Character(key)=>match key.as_str(){
|
||||||
"w"|"W"=>Some(InputInstruction::MoveForward(s)),
|
"w"=>Some(InputInstruction::MoveForward(s)),
|
||||||
"a"|"A"=>Some(InputInstruction::MoveLeft(s)),
|
"a"=>Some(InputInstruction::MoveLeft(s)),
|
||||||
"s"|"S"=>Some(InputInstruction::MoveBack(s)),
|
"s"=>Some(InputInstruction::MoveBack(s)),
|
||||||
"d"|"D"=>Some(InputInstruction::MoveRight(s)),
|
"d"=>Some(InputInstruction::MoveRight(s)),
|
||||||
"e"|"E"=>Some(InputInstruction::MoveUp(s)),
|
"e"=>Some(InputInstruction::MoveUp(s)),
|
||||||
"q"|"Q"=>Some(InputInstruction::MoveDown(s)),
|
"q"=>Some(InputInstruction::MoveDown(s)),
|
||||||
"z"|"Z"=>Some(InputInstruction::Zoom(s)),
|
"z"=>Some(InputInstruction::Zoom(s)),
|
||||||
"r"|"R"=>if s{
|
"r"=>if s{Some(InputInstruction::Reset)}else{None},
|
||||||
//mouse needs to be reset since the position is absolute
|
"f"=>if s{Some(InputInstruction::PracticeFly)}else{None},
|
||||||
self.mouse=strafesnet_common::mouse::MouseState::default();
|
|
||||||
Some(InputInstruction::ResetAndRestart)
|
|
||||||
}else{None},
|
|
||||||
"f"|"F"=>if s{Some(InputInstruction::PracticeFly)}else{None},
|
|
||||||
_=>None,
|
_=>None,
|
||||||
},
|
},
|
||||||
_=>None,
|
_=>None,
|
||||||
}{
|
}{
|
||||||
self.physics_thread.send(TimedInstruction{
|
self.physics_thread.send(TimedInstruction{
|
||||||
time,
|
time,
|
||||||
instruction:crate::physics_worker::Instruction::Input(input_instruction),
|
instruction:crate::physics_worker::Instruction::Interpolate(input_instruction),
|
||||||
}).unwrap();
|
}).unwrap();
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
@ -147,7 +147,7 @@ impl WindowContext<'_>{
|
|||||||
self.mouse.pos+=delta;
|
self.mouse.pos+=delta;
|
||||||
self.physics_thread.send(TimedInstruction{
|
self.physics_thread.send(TimedInstruction{
|
||||||
time,
|
time,
|
||||||
instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
|
instruction:crate::physics_worker::Instruction::Interpolate(InputInstruction::MoveMouse(self.mouse.pos)),
|
||||||
}).unwrap();
|
}).unwrap();
|
||||||
},
|
},
|
||||||
winit::event::DeviceEvent::MouseWheel {
|
winit::event::DeviceEvent::MouseWheel {
|
||||||
@ -157,7 +157,7 @@ impl WindowContext<'_>{
|
|||||||
if false{//self.physics.style.use_scroll{
|
if false{//self.physics.style.use_scroll{
|
||||||
self.physics_thread.send(TimedInstruction{
|
self.physics_thread.send(TimedInstruction{
|
||||||
time,
|
time,
|
||||||
instruction:crate::physics_worker::Instruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
|
instruction:crate::physics_worker::Instruction::Interpolate(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
|
||||||
}).unwrap();
|
}).unwrap();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -165,32 +165,48 @@ impl WindowContext<'_>{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn worker<'a>(
|
|
||||||
|
pub struct WindowContextSetup<'a>{
|
||||||
|
user_settings:crate::settings::UserSettings,
|
||||||
window:&'a winit::window::Window,
|
window:&'a winit::window::Window,
|
||||||
setup_context:crate::setup::SetupContext<'a>,
|
physics:crate::physics::PhysicsContext,
|
||||||
)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
|
graphics:crate::graphics::GraphicsState,
|
||||||
// WindowContextSetup::new
|
}
|
||||||
|
|
||||||
|
impl<'a> WindowContextSetup<'a>{
|
||||||
|
pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
|
||||||
let user_settings=crate::settings::read_user_settings();
|
let user_settings=crate::settings::read_user_settings();
|
||||||
|
|
||||||
let mut graphics=crate::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
|
let mut physics=crate::physics::PhysicsContext::default();
|
||||||
|
physics.load_user_settings(&user_settings);
|
||||||
|
|
||||||
|
let mut graphics=crate::graphics::GraphicsState::new(&context.device,&context.queue,&context.config);
|
||||||
graphics.load_user_settings(&user_settings);
|
graphics.load_user_settings(&user_settings);
|
||||||
|
|
||||||
//WindowContextSetup::into_context
|
Self{
|
||||||
|
user_settings,
|
||||||
|
window,
|
||||||
|
graphics,
|
||||||
|
physics,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{
|
||||||
let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
|
let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
|
||||||
let graphics_thread=crate::graphics_worker::new(graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
|
let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
|
||||||
let mut window_context=WindowContext{
|
WindowContext{
|
||||||
manual_mouse_lock:false,
|
manual_mouse_lock:false,
|
||||||
mouse:strafesnet_common::mouse::MouseState::default(),
|
mouse:crate::physics::MouseState::default(),
|
||||||
//make sure to update this!!!!!
|
//make sure to update this!!!!!
|
||||||
screen_size,
|
screen_size,
|
||||||
window,
|
user_settings:self.user_settings,
|
||||||
physics_thread:crate::physics_worker::new(
|
window:self.window,
|
||||||
graphics_thread,
|
physics_thread:crate::physics_worker::new(self.physics,graphics_thread),
|
||||||
user_settings,
|
}
|
||||||
),
|
}
|
||||||
};
|
|
||||||
|
|
||||||
//WindowContextSetup::into_worker
|
pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
|
||||||
|
let mut window_context=self.into_context(setup_context);
|
||||||
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
|
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
|
||||||
match ins.instruction{
|
match ins.instruction{
|
||||||
WindowInstruction::RequestRedraw=>{
|
WindowInstruction::RequestRedraw=>{
|
||||||
@ -206,7 +222,9 @@ pub fn worker<'a>(
|
|||||||
window_context.physics_thread.send(
|
window_context.physics_thread.send(
|
||||||
TimedInstruction{
|
TimedInstruction{
|
||||||
time:ins.time,
|
time:ins.time,
|
||||||
instruction:crate::physics_worker::Instruction::Resize(size)
|
instruction:crate::physics_worker::Instruction::Passthrough(
|
||||||
|
crate::physics_worker::PassthroughInstruction::Resize(size,window_context.user_settings.clone())
|
||||||
|
)
|
||||||
}
|
}
|
||||||
).unwrap();
|
).unwrap();
|
||||||
}
|
}
|
||||||
@ -214,10 +232,13 @@ pub fn worker<'a>(
|
|||||||
window_context.physics_thread.send(
|
window_context.physics_thread.send(
|
||||||
TimedInstruction{
|
TimedInstruction{
|
||||||
time:ins.time,
|
time:ins.time,
|
||||||
instruction:crate::physics_worker::Instruction::Render
|
instruction:crate::physics_worker::Instruction::Passthrough(
|
||||||
|
crate::physics_worker::PassthroughInstruction::Render
|
||||||
|
)
|
||||||
}
|
}
|
||||||
).unwrap();
|
).unwrap();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
@ -181,16 +181,16 @@ mod test{
|
|||||||
#[test]//How to run this test with printing: cargo test --release -- --nocapture
|
#[test]//How to run this test with printing: cargo test --release -- --nocapture
|
||||||
fn test_worker() {
|
fn test_worker() {
|
||||||
// Create the worker thread
|
// Create the worker thread
|
||||||
let test_body=physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO);
|
let test_body=physics::Body::new(integer::Planar64Vec3::ONE,integer::Planar64Vec3::ONE,integer::Planar64Vec3::ONE,integer::Time::ZERO);
|
||||||
let worker=QRWorker::new(physics::Body::ZERO,
|
let worker=QRWorker::new(physics::Body::default(),
|
||||||
|_|physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO)
|
|_|physics::Body::new(integer::Planar64Vec3::ONE,integer::Planar64Vec3::ONE,integer::Planar64Vec3::ONE,integer::Time::ZERO)
|
||||||
);
|
);
|
||||||
|
|
||||||
// Send tasks to the worker
|
// Send tasks to the worker
|
||||||
for _ in 0..5 {
|
for _ in 0..5 {
|
||||||
let task = instruction::TimedInstruction{
|
let task = instruction::TimedInstruction{
|
||||||
time:integer::Time::ZERO,
|
time:integer::Time::ZERO,
|
||||||
instruction:strafesnet_common::physics::Instruction::Idle,
|
instruction:physics::PhysicsInstruction::StrafeTick,
|
||||||
};
|
};
|
||||||
worker.send(task).unwrap();
|
worker.send(task).unwrap();
|
||||||
}
|
}
|
||||||
@ -204,7 +204,7 @@ mod test{
|
|||||||
// Send a new task
|
// Send a new task
|
||||||
let task = instruction::TimedInstruction{
|
let task = instruction::TimedInstruction{
|
||||||
time:integer::Time::ZERO,
|
time:integer::Time::ZERO,
|
||||||
instruction:strafesnet_common::physics::Instruction::Idle,
|
instruction:physics::PhysicsInstruction::StrafeTick,
|
||||||
};
|
};
|
||||||
worker.send(task).unwrap();
|
worker.send(task).unwrap();
|
||||||
|
|
||||||
|
Loading…
Reference in New Issue
Block a user