forked from StrafesNET/strafe-client
Compare commits
34 Commits
point-phys
...
master
Author | SHA1 | Date | |
---|---|---|---|
f07d9f968e | |||
2cef79da1d | |||
3bad427f61 | |||
90cca51e6e | |||
480cd0e3be | |||
515ca20fb5 | |||
6dff6a2c33 | |||
ae9fc15320 | |||
6ae058d834 | |||
517c4914ac | |||
6ce057ac64 | |||
c86824bdc1 | |||
a7f7edef00 | |||
5b8e5c8899 | |||
14000c016e | |||
1c4191cfc9 | |||
b2f067e0b4 | |||
aec82358ee | |||
5da5006027 | |||
97a1b57b65 | |||
a359650ff8 | |||
1790390055 | |||
49e077996d | |||
9bfcf0b083 | |||
82b3201b0a | |||
513414d4bd | |||
5c4bd4c3c7 | |||
92ec137f33 | |||
5cedf91709 | |||
c201a1a626 | |||
fbae4d9f80 | |||
9374e93801 | |||
0585cfe6f1 | |||
3d96517213 |
1025
Cargo.lock
generated
1025
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
11
Cargo.toml
11
Cargo.toml
@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "strafe-client"
|
name = "strafe-client"
|
||||||
version = "0.8.0"
|
version = "0.9.0"
|
||||||
edition = "2021"
|
edition = "2021"
|
||||||
|
|
||||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||||
@ -9,7 +9,7 @@ edition = "2021"
|
|||||||
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.24.1"
|
glam = "0.25.0"
|
||||||
lazy-regex = "3.0.2"
|
lazy-regex = "3.0.2"
|
||||||
obj = "0.10.2"
|
obj = "0.10.2"
|
||||||
parking_lot = "0.12.1"
|
parking_lot = "0.12.1"
|
||||||
@ -18,8 +18,11 @@ rbx_binary = "0.7.1"
|
|||||||
rbx_dom_weak = "2.5.0"
|
rbx_dom_weak = "2.5.0"
|
||||||
rbx_reflection_database = "0.2.7"
|
rbx_reflection_database = "0.2.7"
|
||||||
rbx_xml = "0.13.1"
|
rbx_xml = "0.13.1"
|
||||||
wgpu = "0.18.0"
|
strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "434ca29aef7e3015c9ca1ed45de8fef42e33fdfb" }
|
||||||
winit = { version = "0.29.2", features = ["rwh_05"] }
|
vbsp = "0.5.0"
|
||||||
|
vmdl = "0.1.1"
|
||||||
|
wgpu = "0.19.0"
|
||||||
|
winit = "0.29.2"
|
||||||
|
|
||||||
#[profile.release]
|
#[profile.release]
|
||||||
#lto = true
|
#lto = true
|
||||||
|
2
LICENSE
2
LICENSE
@ -1,5 +1,5 @@
|
|||||||
/*******************************************************
|
/*******************************************************
|
||||||
* Copyright (C) 2023 Rhys Lloyd <krakow20@gmail.com>
|
* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
|
||||||
*
|
*
|
||||||
* This file is part of the StrafesNET bhop/surf client.
|
* This file is part of the StrafesNET bhop/surf client.
|
||||||
*
|
*
|
||||||
|
43
src/aabb.rs
43
src/aabb.rs
@ -1,43 +0,0 @@
|
|||||||
use crate::integer::Planar64Vec3;
|
|
||||||
|
|
||||||
#[derive(Clone)]
|
|
||||||
pub struct Aabb{
|
|
||||||
pub min:Planar64Vec3,
|
|
||||||
pub max:Planar64Vec3,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for Aabb {
|
|
||||||
fn default()->Self {
|
|
||||||
Self{min:Planar64Vec3::MAX,max:Planar64Vec3::MIN}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Aabb{
|
|
||||||
pub fn grow(&mut self,point:Planar64Vec3){
|
|
||||||
self.min=self.min.min(point);
|
|
||||||
self.max=self.max.max(point);
|
|
||||||
}
|
|
||||||
pub fn join(&mut self,aabb:&Aabb){
|
|
||||||
self.min=self.min.min(aabb.min);
|
|
||||||
self.max=self.max.max(aabb.max);
|
|
||||||
}
|
|
||||||
pub fn inflate(&mut self,hs:Planar64Vec3){
|
|
||||||
self.min-=hs;
|
|
||||||
self.max+=hs;
|
|
||||||
}
|
|
||||||
pub fn intersects(&self,aabb:&Aabb)->bool{
|
|
||||||
(self.min.cmplt(aabb.max)&aabb.min.cmplt(self.max)).all()
|
|
||||||
}
|
|
||||||
pub fn center(&self)->Planar64Vec3{
|
|
||||||
return self.min.midpoint(self.max)
|
|
||||||
}
|
|
||||||
//probably use floats for area & volume because we don't care about precision
|
|
||||||
// pub fn area_weight(&self)->f32{
|
|
||||||
// let d=self.max-self.min;
|
|
||||||
// d.x*d.y+d.y*d.z+d.z*d.x
|
|
||||||
// }
|
|
||||||
// pub fn volume(&self)->f32{
|
|
||||||
// let d=self.max-self.min;
|
|
||||||
// d.x*d.y*d.z
|
|
||||||
// }
|
|
||||||
}
|
|
123
src/bvh.rs
123
src/bvh.rs
@ -1,123 +0,0 @@
|
|||||||
use crate::aabb::Aabb;
|
|
||||||
|
|
||||||
//da algaritum
|
|
||||||
//lista boxens
|
|
||||||
//sort by {minx,maxx,miny,maxy,minz,maxz} (6 lists)
|
|
||||||
//find the sets that minimizes the sum of surface areas
|
|
||||||
//splitting is done when the minimum split sum of surface areas is larger than the node's own surface area
|
|
||||||
|
|
||||||
//start with bisection into octrees because a bad bvh is still 1000x better than no bvh
|
|
||||||
//sort the centerpoints on each axis (3 lists)
|
|
||||||
//bv is put into octant based on whether it is upper or lower in each list
|
|
||||||
enum BvhNodeContent{
|
|
||||||
Branch(Vec<BvhNode>),
|
|
||||||
Leaf(usize),
|
|
||||||
}
|
|
||||||
impl Default for BvhNodeContent{
|
|
||||||
fn default()->Self{
|
|
||||||
Self::Branch(Vec::new())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Default)]
|
|
||||||
pub struct BvhNode{
|
|
||||||
content:BvhNodeContent,
|
|
||||||
aabb:Aabb,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BvhNode{
|
|
||||||
pub fn the_tester<F:FnMut(usize)>(&self,aabb:&Aabb,f:&mut F){
|
|
||||||
match &self.content{
|
|
||||||
&BvhNodeContent::Leaf(model)=>f(model),
|
|
||||||
BvhNodeContent::Branch(children)=>for child in children{
|
|
||||||
//this test could be moved outside the match statement
|
|
||||||
//but that would test the root node aabb
|
|
||||||
//you're probably not going to spend a lot of time outside the map,
|
|
||||||
//so the test is extra work for nothing
|
|
||||||
if aabb.intersects(&child.aabb){
|
|
||||||
child.the_tester(aabb,f);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn generate_bvh(boxen:Vec<Aabb>)->BvhNode{
|
|
||||||
generate_bvh_node(boxen.into_iter().enumerate().collect())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
|
|
||||||
let n=boxen.len();
|
|
||||||
if n<20{
|
|
||||||
let mut aabb=Aabb::default();
|
|
||||||
let nodes=boxen.into_iter().map(|b|{
|
|
||||||
aabb.join(&b.1);
|
|
||||||
BvhNode{
|
|
||||||
content:BvhNodeContent::Leaf(b.0),
|
|
||||||
aabb:b.1,
|
|
||||||
}
|
|
||||||
}).collect();
|
|
||||||
BvhNode{
|
|
||||||
content:BvhNodeContent::Branch(nodes),
|
|
||||||
aabb,
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
let mut octant=std::collections::HashMap::with_capacity(n);//this ids which octant the boxen is put in
|
|
||||||
let mut sort_x=Vec::with_capacity(n);
|
|
||||||
let mut sort_y=Vec::with_capacity(n);
|
|
||||||
let mut sort_z=Vec::with_capacity(n);
|
|
||||||
for (i,aabb) in boxen.iter(){
|
|
||||||
let center=aabb.center();
|
|
||||||
octant.insert(*i,0);
|
|
||||||
sort_x.push((*i,center.x()));
|
|
||||||
sort_y.push((*i,center.y()));
|
|
||||||
sort_z.push((*i,center.z()));
|
|
||||||
}
|
|
||||||
sort_x.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
|
|
||||||
sort_y.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
|
|
||||||
sort_z.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
|
|
||||||
let h=n/2;
|
|
||||||
let median_x=sort_x[h].1;
|
|
||||||
let median_y=sort_y[h].1;
|
|
||||||
let median_z=sort_z[h].1;
|
|
||||||
for (i,c) in sort_x{
|
|
||||||
if median_x<c{
|
|
||||||
octant.insert(i,octant[&i]+1<<0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for (i,c) in sort_y{
|
|
||||||
if median_y<c{
|
|
||||||
octant.insert(i,octant[&i]+1<<1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for (i,c) in sort_z{
|
|
||||||
if median_z<c{
|
|
||||||
octant.insert(i,octant[&i]+1<<2);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//generate lists for unique octant values
|
|
||||||
let mut list_list=Vec::with_capacity(8);
|
|
||||||
let mut octant_list=Vec::with_capacity(8);
|
|
||||||
for (i,aabb) in boxen.into_iter(){
|
|
||||||
let octant_id=octant[&i];
|
|
||||||
let list_id=if let Some(list_id)=octant_list.iter().position(|&id|id==octant_id){
|
|
||||||
list_id
|
|
||||||
}else{
|
|
||||||
let list_id=list_list.len();
|
|
||||||
octant_list.push(octant_id);
|
|
||||||
list_list.push(Vec::new());
|
|
||||||
list_id
|
|
||||||
};
|
|
||||||
list_list[list_id].push((i,aabb));
|
|
||||||
}
|
|
||||||
let mut aabb=Aabb::default();
|
|
||||||
let children=list_list.into_iter().map(|b|{
|
|
||||||
let node=generate_bvh_node(b);
|
|
||||||
aabb.join(&node.aabb);
|
|
||||||
node
|
|
||||||
}).collect();
|
|
||||||
BvhNode{
|
|
||||||
content:BvhNodeContent::Branch(children),
|
|
||||||
aabb,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -1,49 +1,46 @@
|
|||||||
use crate::physics::Body;
|
use crate::physics::Body;
|
||||||
use crate::model_physics::{FEV,MeshQuery};
|
use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
|
||||||
use crate::integer::{Time,Planar64,Planar64Vec3};
|
use strafesnet_common::integer::{Time,Planar64};
|
||||||
use crate::zeroes::zeroes2;
|
use strafesnet_common::zeroes::zeroes2;
|
||||||
|
|
||||||
struct State<FEV>{
|
enum Transition<F,E:DirectedEdge,V>{
|
||||||
fev:FEV,
|
|
||||||
time:Time,
|
|
||||||
}
|
|
||||||
|
|
||||||
enum Transition<F,E,V>{
|
|
||||||
Miss,
|
Miss,
|
||||||
Next(FEV<F,E,V>,Time),
|
Next(FEV<F,E,V>,Time),
|
||||||
Hit(F,Time),
|
Hit(F,Time),
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
|
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>{
|
||||||
fn next_transition(&self,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
|
|
||||||
//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_time=time_limit;
|
let mut best_time=time_limit;
|
||||||
let mut best_transtition=Transition::Miss;
|
let mut best_transtition=Transition::Miss;
|
||||||
match &self.fev{
|
match fev{
|
||||||
&FEV::<F,E,V>::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?
|
||||||
|
//use the mesh transform translation instead of baking it into the d value.
|
||||||
for t in 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)){
|
||||||
let t=body.time+Time::from(t);
|
let t=body.time+Time::from(t);
|
||||||
if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=t;
|
best_time=t;
|
||||||
best_transtition=Transition::Hit(face_id,t);
|
best_transtition=Transition::Hit(face_id,t);
|
||||||
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
//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 &(edge_id,test_face_id) in mesh.face_edges(face_id).iter(){
|
for &directed_edge_id in mesh.face_edges(face_id).iter(){
|
||||||
let edge_n=mesh.edge_n(edge_id);
|
let edge_n=mesh.directed_edge_n(directed_edge_id);
|
||||||
let n=n.cross(edge_n);
|
let n=n.cross(edge_n);
|
||||||
//picking a vert randomly is terrible
|
let verts=mesh.edge_verts(directed_edge_id.as_undirected());
|
||||||
let d=n.dot(mesh.vert(mesh.edge_verts(edge_id)[0]));
|
//WARNING: d is moved out of the *2 block because of adding two vertices!
|
||||||
for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
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)){
|
||||||
let t=body.time+Time::from(t);
|
let t=body.time+Time::from(t);
|
||||||
if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=t;
|
best_time=t;
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(edge_id),t);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -53,26 +50,29 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
|
|||||||
&FEV::<F,E,V>::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);
|
||||||
for &test_face_id in mesh.edge_faces(edge_id).iter(){
|
let edge_verts=mesh.edge_verts(edge_id);
|
||||||
let face_n=mesh.face_nd(test_face_id).0;
|
let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
|
||||||
let n=edge_n.cross(face_n);
|
for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
|
||||||
let d=n.dot(mesh.vert(mesh.edge_verts(edge_id)[0]));
|
let face_n=mesh.face_nd(edge_face_id).0;
|
||||||
for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
//edge_n gets parity from the order of edge_faces
|
||||||
|
let n=face_n.cross(edge_n)*((i as i64)*2-1);
|
||||||
|
//WARNING yada yada d *2
|
||||||
|
for t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
|
||||||
let t=body.time+Time::from(t);
|
let t=body.time+Time::from(t);
|
||||||
if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=t;
|
best_time=t;
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Face(test_face_id),t);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
//test each vertex collision time, ignoring roots with zero or conflicting derivative
|
//test each vertex collision time, ignoring roots with zero or conflicting derivative
|
||||||
let n=mesh.edge_n(edge_id);
|
for (i,&vert_id) in edge_verts.iter().enumerate(){
|
||||||
for &vert_id in mesh.edge_verts(edge_id).iter(){
|
//vertex normal gets parity from vert index
|
||||||
let d=n.dot(mesh.vert(vert_id));
|
let n=edge_n*(1-2*(i as i64));
|
||||||
for t in zeroes2((n.dot(body.position)-d)*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)){
|
||||||
let t=body.time+Time::from(t);
|
let t=body.time+Time::from(t);
|
||||||
if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=t;
|
best_time=t;
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
|
||||||
break;
|
break;
|
||||||
@ -83,14 +83,14 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
|
|||||||
},
|
},
|
||||||
&FEV::<F,E,V>::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 &edge_id in mesh.vert_edges(vert_id).iter(){
|
for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
|
||||||
let n=mesh.edge_n(edge_id);
|
//edge is directed away from vertex, but we want the dot product to turn out negative
|
||||||
let d=n.dot(mesh.vert(vert_id));
|
let n=-mesh.directed_edge_n(directed_edge_id);
|
||||||
for t in zeroes2((n.dot(body.position)-d)*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)){
|
||||||
let t=body.time+Time::from(t);
|
let t=body.time+Time::from(t);
|
||||||
if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
||||||
best_time=t;
|
best_time=t;
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(edge_id),t);
|
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -100,27 +100,20 @@ impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
|
|||||||
}
|
}
|
||||||
best_transtition
|
best_transtition
|
||||||
}
|
}
|
||||||
|
pub enum CrawlResult<F,E:DirectedEdge,V>{
|
||||||
|
Miss(FEV<F,E,V>),
|
||||||
|
Hit(F,Time),
|
||||||
}
|
}
|
||||||
|
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 predict_collision<F:Copy,E:Copy,V:Copy>(mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time)->Option<(F,Time)>{
|
let mut time=start_time;
|
||||||
let mut state=State{
|
for _ in 0..20{
|
||||||
fev:mesh.closest_fev(relative_body.position),
|
match next_transition(&fev,time,mesh,relative_body,time_limit){
|
||||||
time:relative_body.time,
|
Transition::Miss=>return CrawlResult::Miss(fev),
|
||||||
};
|
Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
|
||||||
//it would be possible to write down the point of closest approach...
|
Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
|
||||||
loop{
|
|
||||||
match state.next_transition(mesh,relative_body,time_limit){
|
|
||||||
Transition::Miss=>return None,
|
|
||||||
Transition::Next(fev,time)=>(state.fev,state.time)=(fev,time),
|
|
||||||
Transition::Hit(face,time)=>return Some((face,time)),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
//TODO: fix all bugs
|
||||||
|
println!("Too many iterations! Using default behaviour instead of crashing...");
|
||||||
pub fn predict_collision_end<F:Copy,E:Copy,V:Copy>(mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time,ignore_face_id:F)->Option<(F,Time)>{
|
CrawlResult::Miss(fev)
|
||||||
//imagine the mesh without the collision face
|
|
||||||
//no algorithm needed, there is only one state and three cases (Face,Edge,None)
|
|
||||||
//determine when it passes an edge ("sliding off" case) or if it leaves the surface directly
|
|
||||||
//the state can be constructed from the ContactCollision directly
|
|
||||||
None
|
|
||||||
}
|
}
|
||||||
|
@ -1,4 +1,5 @@
|
|||||||
use std::borrow::Cow;
|
use std::borrow::Cow;
|
||||||
|
use strafesnet_common::integer;
|
||||||
use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
|
use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
|
||||||
use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
|
use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
|
||||||
|
|
||||||
@ -152,11 +153,14 @@ impl GraphicsState{
|
|||||||
let mut texture_loading_threads=Vec::new();
|
let mut texture_loading_threads=Vec::new();
|
||||||
let num_textures=indexed_models.textures.len();
|
let num_textures=indexed_models.textures.len();
|
||||||
for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
|
for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
|
||||||
if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",texture_id))){
|
let path=std::path::PathBuf::from(format!("textures/{}.dds",texture_id));
|
||||||
|
if let Ok(mut file) = std::fs::File::open(path.clone()){
|
||||||
double_map.insert(i as u32, texture_loading_threads.len() as u32);
|
double_map.insert(i as u32, texture_loading_threads.len() as u32);
|
||||||
texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
|
texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
|
||||||
ddsfile::Dds::read(&mut file).unwrap()
|
ddsfile::Dds::read(&mut file).unwrap()
|
||||||
})));
|
})));
|
||||||
|
}else{
|
||||||
|
//println!("missing texture path={:?}",path);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -200,6 +204,7 @@ impl GraphicsState{
|
|||||||
label: Some(format!("Texture{}",texture_id).as_str()),
|
label: Some(format!("Texture{}",texture_id).as_str()),
|
||||||
view_formats: &[],
|
view_formats: &[],
|
||||||
},
|
},
|
||||||
|
wgpu::util::TextureDataOrder::LayerMajor,
|
||||||
&image.data,
|
&image.data,
|
||||||
);
|
);
|
||||||
texture.create_view(&wgpu::TextureViewDescriptor {
|
texture.create_view(&wgpu::TextureViewDescriptor {
|
||||||
@ -216,7 +221,7 @@ impl GraphicsState{
|
|||||||
for model in indexed_models.models.into_iter(){
|
for model in indexed_models.models.into_iter(){
|
||||||
//convert ModelInstance into GraphicsModelInstance
|
//convert ModelInstance into GraphicsModelInstance
|
||||||
let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
|
let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
|
||||||
if instance.color.w==0.0{
|
if instance.color.w==0.0&&!model.groups.iter().any(|g|g.texture.is_some()){
|
||||||
None
|
None
|
||||||
}else{
|
}else{
|
||||||
Some(GraphicsModelInstance{
|
Some(GraphicsModelInstance{
|
||||||
@ -697,6 +702,7 @@ impl GraphicsState{
|
|||||||
label: Some("Skybox Texture"),
|
label: Some("Skybox Texture"),
|
||||||
view_formats: &[],
|
view_formats: &[],
|
||||||
},
|
},
|
||||||
|
wgpu::util::TextureDataOrder::LayerMajor,
|
||||||
&skybox_image.data,
|
&skybox_image.data,
|
||||||
);
|
);
|
||||||
|
|
||||||
@ -737,6 +743,7 @@ impl GraphicsState{
|
|||||||
label: Some("Squid Texture"),
|
label: Some("Squid Texture"),
|
||||||
view_formats: &[],
|
view_formats: &[],
|
||||||
},
|
},
|
||||||
|
wgpu::util::TextureDataOrder::LayerMajor,
|
||||||
&image.data,
|
&image.data,
|
||||||
);
|
);
|
||||||
|
|
||||||
@ -827,7 +834,7 @@ impl GraphicsState{
|
|||||||
});
|
});
|
||||||
|
|
||||||
let camera=GraphicsCamera::default();
|
let camera=GraphicsCamera::default();
|
||||||
let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,crate::integer::Time::ZERO));
|
let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,integer::Time::ZERO));
|
||||||
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),
|
||||||
@ -896,7 +903,7 @@ impl GraphicsState{
|
|||||||
device:&wgpu::Device,
|
device:&wgpu::Device,
|
||||||
queue:&wgpu::Queue,
|
queue:&wgpu::Queue,
|
||||||
physics_output:crate::physics::PhysicsOutputState,
|
physics_output:crate::physics::PhysicsOutputState,
|
||||||
predicted_time:crate::integer::Time,
|
predicted_time:integer::Time,
|
||||||
mouse_pos:glam::IVec2,
|
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
|
||||||
|
@ -1,5 +1,7 @@
|
|||||||
|
use strafesnet_common::integer;
|
||||||
|
|
||||||
pub enum Instruction{
|
pub enum Instruction{
|
||||||
Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
|
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),
|
||||||
GenerateModels(crate::model::IndexedModelInstances),
|
GenerateModels(crate::model::IndexedModelInstances),
|
||||||
@ -18,7 +20,7 @@ WorkerDescription{
|
|||||||
pub fn new<'a>(
|
pub fn new<'a>(
|
||||||
mut graphics:crate::graphics::GraphicsState,
|
mut graphics:crate::graphics::GraphicsState,
|
||||||
mut config:wgpu::SurfaceConfiguration,
|
mut config:wgpu::SurfaceConfiguration,
|
||||||
surface:wgpu::Surface,
|
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>{
|
||||||
|
@ -1,53 +0,0 @@
|
|||||||
use crate::integer::Time;
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct TimedInstruction<I>{
|
|
||||||
pub time:Time,
|
|
||||||
pub instruction:I,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait InstructionEmitter<I>{
|
|
||||||
fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<I>>;
|
|
||||||
}
|
|
||||||
pub trait InstructionConsumer<I>{
|
|
||||||
fn process_instruction(&mut self, instruction:TimedInstruction<I>);
|
|
||||||
}
|
|
||||||
|
|
||||||
//PROPER PRIVATE FIELDS!!!
|
|
||||||
pub struct InstructionCollector<I>{
|
|
||||||
time:Time,
|
|
||||||
instruction:Option<I>,
|
|
||||||
}
|
|
||||||
impl<I> InstructionCollector<I>{
|
|
||||||
pub fn new(time:Time)->Self{
|
|
||||||
Self{
|
|
||||||
time,
|
|
||||||
instruction:None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
pub fn time(&self)->Time{
|
|
||||||
self.time
|
|
||||||
}
|
|
||||||
pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
|
|
||||||
match instruction{
|
|
||||||
Some(unwrap_instruction)=>{
|
|
||||||
if unwrap_instruction.time<self.time {
|
|
||||||
self.time=unwrap_instruction.time;
|
|
||||||
self.instruction=Some(unwrap_instruction.instruction);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
None=>(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn instruction(self)->Option<TimedInstruction<I>>{
|
|
||||||
//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
|
|
||||||
match self.instruction{
|
|
||||||
Some(instruction)=>Some(TimedInstruction{
|
|
||||||
time:self.time,
|
|
||||||
instruction
|
|
||||||
}),
|
|
||||||
None=>None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
1029
src/integer.rs
1029
src/integer.rs
File diff suppressed because it is too large
Load Diff
232
src/load_bsp.rs
Normal file
232
src/load_bsp.rs
Normal file
@ -0,0 +1,232 @@
|
|||||||
|
use strafesnet_common::integer;
|
||||||
|
|
||||||
|
const VALVE_SCALE:f32=1.0/16.0;
|
||||||
|
fn valve_transform(v:[f32;3])->integer::Planar64Vec3{
|
||||||
|
integer::Planar64Vec3::try_from([v[0]*VALVE_SCALE,v[2]*VALVE_SCALE,-v[1]*VALVE_SCALE]).unwrap()
|
||||||
|
}
|
||||||
|
pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Result<crate::model::IndexedModelInstances,vbsp::BspError>{
|
||||||
|
let mut s=Vec::new();
|
||||||
|
|
||||||
|
match input.read_to_end(&mut s){
|
||||||
|
Ok(_)=>(),
|
||||||
|
Err(e)=>println!("load_bsp::generate_indexed_models read_to_end failed: {:?}",e),
|
||||||
|
}
|
||||||
|
|
||||||
|
match vbsp::Bsp::read(s.as_slice()){
|
||||||
|
Ok(bsp)=>{
|
||||||
|
let mut spawn_point=integer::Planar64Vec3::ZERO;
|
||||||
|
|
||||||
|
let mut name_from_texture_id=Vec::new();
|
||||||
|
let mut texture_id_from_name=std::collections::HashMap::new();
|
||||||
|
|
||||||
|
let mut models=bsp.models().map(|world_model|{
|
||||||
|
//non-deduplicated
|
||||||
|
let mut spam_pos=Vec::new();
|
||||||
|
let mut spam_tex=Vec::new();
|
||||||
|
let mut spam_normal=Vec::new();
|
||||||
|
let mut spam_vertices=Vec::new();
|
||||||
|
let groups=world_model.faces()
|
||||||
|
.filter(|face| face.is_visible())//TODO: look at this
|
||||||
|
.map(|face|{
|
||||||
|
let face_texture=face.texture();
|
||||||
|
let face_texture_data=face_texture.texture_data();
|
||||||
|
let (texture_u,texture_v)=(glam::Vec3A::from_slice(&face_texture.texture_transforms_u[0..3]),glam::Vec3A::from_slice(&face_texture.texture_transforms_v[0..3]));
|
||||||
|
let texture_offset=glam::vec2(face_texture.texture_transforms_u[3],face_texture.texture_transforms_v[3]);
|
||||||
|
let texture_size=glam::vec2(face_texture_data.width as f32,face_texture_data.height as f32);
|
||||||
|
|
||||||
|
//texture
|
||||||
|
let texture_id=if let Some(&texture_id)=texture_id_from_name.get(face_texture_data.name()){
|
||||||
|
texture_id
|
||||||
|
}else{
|
||||||
|
let texture_id=name_from_texture_id.len() as u32;
|
||||||
|
texture_id_from_name.insert(face_texture_data.name().to_string(),texture_id);
|
||||||
|
name_from_texture_id.push(face_texture_data.name().to_string());
|
||||||
|
texture_id
|
||||||
|
};
|
||||||
|
|
||||||
|
//normal
|
||||||
|
let normal=face.normal();
|
||||||
|
let normal_idx=spam_normal.len() as u32;
|
||||||
|
spam_normal.push(valve_transform(<[f32;3]>::from(normal)));
|
||||||
|
let mut vertices:Vec<u32>=face.vertex_positions().map(|vertex_pos|{
|
||||||
|
let vertex_xyz=<[f32;3]>::from(vertex_pos);
|
||||||
|
let pos=glam::Vec3A::from_array(vertex_xyz);
|
||||||
|
let pos_idx=spam_pos.len();
|
||||||
|
spam_pos.push(valve_transform(vertex_xyz));
|
||||||
|
|
||||||
|
//calculate texture coordinates
|
||||||
|
let tex=(glam::vec2(pos.dot(texture_u),pos.dot(texture_v))+texture_offset)/texture_size;
|
||||||
|
let tex_idx=spam_tex.len() as u32;
|
||||||
|
spam_tex.push(tex);
|
||||||
|
|
||||||
|
let i=spam_vertices.len() as u32;
|
||||||
|
spam_vertices.push(crate::model::IndexedVertex{
|
||||||
|
pos: pos_idx as u32,
|
||||||
|
tex: tex_idx as u32,
|
||||||
|
normal: normal_idx,
|
||||||
|
color: 0,
|
||||||
|
});
|
||||||
|
i
|
||||||
|
}).collect();
|
||||||
|
vertices.reverse();
|
||||||
|
crate::model::IndexedGroup{
|
||||||
|
texture:Some(texture_id),
|
||||||
|
polys:vec![crate::model::IndexedPolygon{vertices}],
|
||||||
|
}
|
||||||
|
}).collect();
|
||||||
|
crate::model::IndexedModel{
|
||||||
|
unique_pos:spam_pos,
|
||||||
|
unique_tex:spam_tex,
|
||||||
|
unique_normal:spam_normal,
|
||||||
|
unique_color:vec![glam::Vec4::ONE],
|
||||||
|
unique_vertices:spam_vertices,
|
||||||
|
groups,
|
||||||
|
instances:vec![crate::model::ModelInstance{
|
||||||
|
attributes:crate::model::CollisionAttributes::Decoration,
|
||||||
|
transform:integer::Planar64Affine3::new(
|
||||||
|
integer::Planar64Mat3::default(),
|
||||||
|
valve_transform(<[f32;3]>::from(world_model.origin))
|
||||||
|
),
|
||||||
|
..Default::default()
|
||||||
|
}],
|
||||||
|
}
|
||||||
|
}).collect();
|
||||||
|
|
||||||
|
//dedupe prop models
|
||||||
|
let mut model_dedupe=std::collections::HashSet::new();
|
||||||
|
for prop in bsp.static_props(){
|
||||||
|
model_dedupe.insert(prop.model());
|
||||||
|
}
|
||||||
|
|
||||||
|
//generate unique meshes
|
||||||
|
let mut model_map=std::collections::HashMap::with_capacity(model_dedupe.len());
|
||||||
|
let mut prop_models=Vec::new();
|
||||||
|
for model_name in model_dedupe{
|
||||||
|
let model_name_lower=model_name.to_lowercase();
|
||||||
|
//.mdl, .vvd, .dx90.vtx
|
||||||
|
let mut path=std::path::PathBuf::from(model_name_lower.as_str());
|
||||||
|
let file_name=std::path::PathBuf::from(path.file_stem().unwrap());
|
||||||
|
path.pop();
|
||||||
|
path.push(file_name);
|
||||||
|
let mut vvd_path=path.clone();
|
||||||
|
let mut vtx_path=path.clone();
|
||||||
|
vvd_path.set_extension("vvd");
|
||||||
|
vtx_path.set_extension("dx90.vtx");
|
||||||
|
match (bsp.pack.get(model_name_lower.as_str()),bsp.pack.get(vvd_path.as_os_str().to_str().unwrap()),bsp.pack.get(vtx_path.as_os_str().to_str().unwrap())){
|
||||||
|
(Ok(Some(mdl_file)),Ok(Some(vvd_file)),Ok(Some(vtx_file)))=>{
|
||||||
|
match (vmdl::mdl::Mdl::read(mdl_file.as_ref()),vmdl::vvd::Vvd::read(vvd_file.as_ref()),vmdl::vtx::Vtx::read(vtx_file.as_ref())){
|
||||||
|
(Ok(mdl),Ok(vvd),Ok(vtx))=>{
|
||||||
|
let model=vmdl::Model::from_parts(mdl,vtx,vvd);
|
||||||
|
let texture_paths=model.texture_directories();
|
||||||
|
if texture_paths.len()!=1{
|
||||||
|
println!("WARNING: multiple texture paths");
|
||||||
|
}
|
||||||
|
let skin=model.skin_tables().nth(0).unwrap();
|
||||||
|
|
||||||
|
let mut spam_pos=Vec::with_capacity(model.vertices().len());
|
||||||
|
let mut spam_normal=Vec::with_capacity(model.vertices().len());
|
||||||
|
let mut spam_tex=Vec::with_capacity(model.vertices().len());
|
||||||
|
let mut spam_vertices=Vec::with_capacity(model.vertices().len());
|
||||||
|
for (i,vertex) in model.vertices().iter().enumerate(){
|
||||||
|
spam_pos.push(valve_transform(<[f32;3]>::from(vertex.position)));
|
||||||
|
spam_normal.push(valve_transform(<[f32;3]>::from(vertex.normal)));
|
||||||
|
spam_tex.push(glam::Vec2::from_array(vertex.texture_coordinates));
|
||||||
|
spam_vertices.push(crate::model::IndexedVertex{
|
||||||
|
pos:i as u32,
|
||||||
|
tex:i as u32,
|
||||||
|
normal:i as u32,
|
||||||
|
color:0,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
let model_id=prop_models.len();
|
||||||
|
model_map.insert(model_name,model_id);
|
||||||
|
prop_models.push(crate::model::IndexedModel{
|
||||||
|
unique_pos:spam_pos,
|
||||||
|
unique_normal:spam_normal,
|
||||||
|
unique_tex:spam_tex,
|
||||||
|
unique_color:vec![glam::Vec4::ONE],
|
||||||
|
unique_vertices:spam_vertices,
|
||||||
|
groups:model.meshes().map(|mesh|{
|
||||||
|
let texture=if let (Some(texture_path),Some(texture_name))=(texture_paths.get(0),skin.texture(mesh.material_index())){
|
||||||
|
let mut path=std::path::PathBuf::from(texture_path.as_str());
|
||||||
|
path.push(texture_name);
|
||||||
|
let texture_location=path.as_os_str().to_str().unwrap();
|
||||||
|
let texture_id=if let Some(&texture_id)=texture_id_from_name.get(texture_location){
|
||||||
|
texture_id
|
||||||
|
}else{
|
||||||
|
println!("texture! {}",texture_location);
|
||||||
|
let texture_id=name_from_texture_id.len() as u32;
|
||||||
|
texture_id_from_name.insert(texture_location.to_string(),texture_id);
|
||||||
|
name_from_texture_id.push(texture_location.to_string());
|
||||||
|
texture_id
|
||||||
|
};
|
||||||
|
Some(texture_id)
|
||||||
|
}else{
|
||||||
|
None
|
||||||
|
};
|
||||||
|
|
||||||
|
crate::model::IndexedGroup{
|
||||||
|
texture,
|
||||||
|
polys:{
|
||||||
|
//looking at the code, it would seem that the strips are pre-deindexed into triangle lists when calling this function
|
||||||
|
mesh.vertex_strip_indices().map(|strip|{
|
||||||
|
strip.collect::<Vec<usize>>().chunks(3).map(|tri|{
|
||||||
|
crate::model::IndexedPolygon{vertices:vec![tri[0] as u32,tri[1] as u32,tri[2] as u32]}
|
||||||
|
}).collect::<Vec<crate::model::IndexedPolygon>>()
|
||||||
|
}).flatten().collect()
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}).collect(),
|
||||||
|
instances:Vec::new(),
|
||||||
|
});
|
||||||
|
},
|
||||||
|
_=>println!("model_name={} error",model_name),
|
||||||
|
}
|
||||||
|
},
|
||||||
|
_=>println!("no model name={}",model_name),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//generate model instances
|
||||||
|
for prop in bsp.static_props(){
|
||||||
|
let placement=prop.as_prop_placement();
|
||||||
|
if let Some(&model_index)=model_map.get(placement.model){
|
||||||
|
prop_models[model_index].instances.push(crate::model::ModelInstance{
|
||||||
|
transform:integer::Planar64Affine3::new(
|
||||||
|
integer::Planar64Mat3::try_from(
|
||||||
|
glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
|
||||||
|
//TODO: figure this out
|
||||||
|
*glam::Mat3A::from_quat(glam::Quat::from_xyzw(
|
||||||
|
placement.rotation.v.x,//b
|
||||||
|
placement.rotation.v.y,//c
|
||||||
|
placement.rotation.v.z,//d
|
||||||
|
placement.rotation.s,//a
|
||||||
|
))
|
||||||
|
).unwrap(),
|
||||||
|
valve_transform(<[f32;3]>::from(placement.origin)),
|
||||||
|
),
|
||||||
|
attributes:crate::model::CollisionAttributes::Decoration,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
}else{
|
||||||
|
//println!("model not found {}",placement.model);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//actually add the prop models
|
||||||
|
prop_models.append(&mut models);
|
||||||
|
|
||||||
|
Ok(crate::model::IndexedModelInstances{
|
||||||
|
textures:name_from_texture_id,
|
||||||
|
models:prop_models,
|
||||||
|
spawn_point,
|
||||||
|
modes:Vec::new(),
|
||||||
|
})
|
||||||
|
},
|
||||||
|
Err(e)=>{
|
||||||
|
println!("rotten {:?}",e);
|
||||||
|
Err(e)
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
@ -1,5 +1,5 @@
|
|||||||
use crate::primitives;
|
use crate::primitives;
|
||||||
use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
|
use strafesnet_common::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
|
||||||
|
|
||||||
fn class_is_a(class: &str, superclass: &str) -> bool {
|
fn class_is_a(class: &str, superclass: &str) -> bool {
|
||||||
if class==superclass {
|
if class==superclass {
|
||||||
@ -14,12 +14,15 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
|
|||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
|
fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
|
||||||
for &referent in instance.children() {
|
let mut stack=vec![instance];
|
||||||
if let Some(c) = dom.get_by_ref(referent) {
|
while let Some(item)=stack.pop(){
|
||||||
if class_is_a(c.class.as_str(), superclass) {
|
for &referent in item.children(){
|
||||||
objects.push(c.referent());//copy ref
|
if let Some(c)=dom.get_by_ref(referent){
|
||||||
|
if class_is_a(c.class.as_str(),superclass){
|
||||||
|
objects.push(c.referent());//copy ref
|
||||||
|
}
|
||||||
|
stack.push(c);
|
||||||
}
|
}
|
||||||
recursive_collect_superclass(objects,dom,c,superclass);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -262,6 +265,18 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
{
|
{
|
||||||
let model_transform=planar64_affine3_from_roblox(cf,size);
|
let model_transform=planar64_affine3_from_roblox(cf,size);
|
||||||
|
|
||||||
|
if model_transform.matrix3.determinant()==Planar64::ZERO{
|
||||||
|
let mut parent_ref=object.parent();
|
||||||
|
let mut full_path=object.name.clone();
|
||||||
|
while let Some(parent)=dom.get_by_ref(parent_ref){
|
||||||
|
full_path=format!("{}.{}",parent.name,full_path);
|
||||||
|
parent_ref=parent.parent();
|
||||||
|
}
|
||||||
|
println!("Zero determinant CFrame at location {}",full_path);
|
||||||
|
println!("matrix3:{}",model_transform.matrix3);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
//push TempIndexedAttributes
|
//push TempIndexedAttributes
|
||||||
let mut force_intersecting=false;
|
let mut force_intersecting=false;
|
||||||
let mut temp_indexing_attributes=Vec::new();
|
let mut temp_indexing_attributes=Vec::new();
|
||||||
|
13
src/main.rs
13
src/main.rs
@ -1,16 +1,14 @@
|
|||||||
mod bvh;
|
use strafesnet_common::integer;
|
||||||
mod aabb;
|
|
||||||
mod model;
|
mod model;
|
||||||
mod setup;
|
mod setup;
|
||||||
mod window;
|
mod window;
|
||||||
mod worker;
|
mod worker;
|
||||||
mod zeroes;
|
|
||||||
mod integer;
|
|
||||||
mod physics;
|
mod physics;
|
||||||
mod graphics;
|
mod graphics;
|
||||||
mod settings;
|
mod settings;
|
||||||
mod primitives;
|
mod primitives;
|
||||||
mod instruction;
|
mod load_bsp;
|
||||||
mod load_roblox;
|
mod load_roblox;
|
||||||
mod face_crawler;
|
mod face_crawler;
|
||||||
mod compat_worker;
|
mod compat_worker;
|
||||||
@ -46,7 +44,7 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
|
|||||||
},
|
},
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
//b"VBSP"=>Some(load_bsp::generate_indexed_models(input)),
|
b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(),
|
||||||
//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
|
//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
|
||||||
//b"SNFB"=>Some(sniffer::load_bot(input)),
|
//b"SNFB"=>Some(sniffer::load_bot(input)),
|
||||||
other=>{
|
other=>{
|
||||||
@ -116,6 +114,5 @@ pub fn default_models()->model::IndexedModelInstances{
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn main(){
|
fn main(){
|
||||||
let context=setup::setup(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str());
|
setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
|
||||||
context.start();//creates and runs a window context
|
|
||||||
}
|
}
|
||||||
|
@ -1,4 +1,4 @@
|
|||||||
use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
|
use strafesnet_common::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
|
||||||
pub type TextureCoordinate=glam::Vec2;
|
pub type TextureCoordinate=glam::Vec2;
|
||||||
pub type Color4=glam::Vec4;
|
pub type Color4=glam::Vec4;
|
||||||
#[derive(Clone,Hash,PartialEq,Eq)]
|
#[derive(Clone,Hash,PartialEq,Eq)]
|
||||||
@ -259,7 +259,6 @@ impl IntersectingAttributes{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
//Spawn(u32) NO! spawns are indexed in the map header instead of marked with attibutes
|
//Spawn(u32) NO! spawns are indexed in the map header instead of marked with attibutes
|
||||||
//TODO: deduplicate attributes
|
|
||||||
pub enum CollisionAttributes{
|
pub enum CollisionAttributes{
|
||||||
Decoration,//visual only
|
Decoration,//visual only
|
||||||
Contact{//track whether you are contacting the object
|
Contact{//track whether you are contacting the object
|
||||||
|
File diff suppressed because it is too large
Load Diff
541
src/physics.rs
541
src/physics.rs
@ -1,6 +1,8 @@
|
|||||||
use crate::instruction::{InstructionEmitter,InstructionConsumer,TimedInstruction};
|
|
||||||
use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
|
|
||||||
use crate::model_physics::{PhysicsMesh,TransformedMesh,MeshQuery};
|
use crate::model_physics::{PhysicsMesh,TransformedMesh,MeshQuery};
|
||||||
|
use strafesnet_common::bvh;
|
||||||
|
use strafesnet_common::aabb;
|
||||||
|
use strafesnet_common::instruction::{self,InstructionEmitter,InstructionConsumer,TimedInstruction};
|
||||||
|
use strafesnet_common::integer::{self,Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum PhysicsInstruction {
|
pub enum PhysicsInstruction {
|
||||||
@ -43,6 +45,17 @@ pub struct Body{
|
|||||||
pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
|
pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
|
||||||
pub time:Time,//nanoseconds x xxxxD!
|
pub time:Time,//nanoseconds x xxxxD!
|
||||||
}
|
}
|
||||||
|
impl std::ops::Neg for Body{
|
||||||
|
type Output=Self;
|
||||||
|
fn neg(self)->Self::Output{
|
||||||
|
Self{
|
||||||
|
position:self.position,
|
||||||
|
velocity:-self.velocity,
|
||||||
|
acceleration:self.acceleration,
|
||||||
|
time:-self.time,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
//hey dumbass just use a delta
|
//hey dumbass just use a delta
|
||||||
#[derive(Clone,Debug)]
|
#[derive(Clone,Debug)]
|
||||||
@ -175,9 +188,9 @@ impl PhysicsModels{
|
|||||||
self.attributes.clear();
|
self.attributes.clear();
|
||||||
self.model_id_from_wormhole_id.clear();
|
self.model_id_from_wormhole_id.clear();
|
||||||
}
|
}
|
||||||
fn aabb_list(&self)->Vec<crate::aabb::Aabb>{
|
fn aabb_list(&self)->Vec<aabb::Aabb>{
|
||||||
self.models.iter().map(|model|{
|
self.models.iter().map(|model|{
|
||||||
let mut aabb=crate::aabb::Aabb::default();
|
let mut aabb=aabb::Aabb::default();
|
||||||
for pos in self.meshes[model.mesh_id].verts(){
|
for pos in self.meshes[model.mesh_id].verts(){
|
||||||
aabb.grow(model.transform.transform_point3(pos));
|
aabb.grow(model.transform.transform_point3(pos));
|
||||||
}
|
}
|
||||||
@ -191,6 +204,7 @@ impl PhysicsModels{
|
|||||||
&self.meshes[self.models[model_id].mesh_id],
|
&self.meshes[self.models[model_id].mesh_id],
|
||||||
&self.models[model_id].transform,
|
&self.models[model_id].transform,
|
||||||
&self.models[model_id].normal_transform,
|
&self.models[model_id].normal_transform,
|
||||||
|
self.models[model_id].transform_det,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
fn model(&self,model_id:usize)->&PhysicsModel{
|
fn model(&self,model_id:usize)->&PhysicsModel{
|
||||||
@ -327,6 +341,60 @@ struct StrafeSettings{
|
|||||||
tick_rate:Ratio64,
|
tick_rate:Ratio64,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
struct Hitbox{
|
||||||
|
halfsize:Planar64Vec3,
|
||||||
|
mesh:PhysicsMesh,
|
||||||
|
transform:integer::Planar64Affine3,
|
||||||
|
normal_transform:Planar64Mat3,
|
||||||
|
transform_det:Planar64,
|
||||||
|
}
|
||||||
|
impl Hitbox{
|
||||||
|
fn new(mesh:PhysicsMesh,transform:integer::Planar64Affine3)->Self{
|
||||||
|
//calculate extents
|
||||||
|
let mut aabb=aabb::Aabb::default();
|
||||||
|
for vert in mesh.verts(){
|
||||||
|
aabb.grow(transform.transform_point3(vert));
|
||||||
|
}
|
||||||
|
Self{
|
||||||
|
halfsize:aabb.size()/2,
|
||||||
|
mesh,
|
||||||
|
transform,
|
||||||
|
normal_transform:transform.matrix3.inverse_times_det().transpose(),
|
||||||
|
transform_det:transform.matrix3.determinant(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn from_mesh_scale(mesh:PhysicsMesh,scale:Planar64Vec3)->Self{
|
||||||
|
let matrix3=Planar64Mat3::from_diagonal(scale);
|
||||||
|
Self{
|
||||||
|
halfsize:scale,
|
||||||
|
mesh,
|
||||||
|
normal_transform:matrix3.inverse_times_det().transpose(),
|
||||||
|
transform:integer::Planar64Affine3::new(matrix3,Planar64Vec3::ZERO),
|
||||||
|
transform_det:matrix3.determinant(),//scale.x*scale.y*scale.z but whatever
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn from_mesh_scale_offset(mesh:PhysicsMesh,scale:Planar64Vec3,offset:Planar64Vec3)->Self{
|
||||||
|
let matrix3=Planar64Mat3::from_diagonal(scale);
|
||||||
|
Self{
|
||||||
|
halfsize:scale,
|
||||||
|
mesh,
|
||||||
|
normal_transform:matrix3.inverse_times_det().transpose(),
|
||||||
|
transform:integer::Planar64Affine3::new(matrix3,offset),
|
||||||
|
transform_det:matrix3.determinant(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn roblox()->Self{
|
||||||
|
Self::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cylinder()),Planar64Vec3::int(2,5,2)/2)
|
||||||
|
}
|
||||||
|
fn source()->Self{
|
||||||
|
Self::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cube()),Planar64Vec3::raw(33<<28,73<<28,33<<28)/2)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn transformed_mesh(&self)->TransformedMesh{
|
||||||
|
TransformedMesh::new(&self.mesh,&self.transform,&self.normal_transform,self.transform_det)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
struct StyleModifiers{
|
struct StyleModifiers{
|
||||||
controls_used:u32,//controls which are allowed to pass into gameplay
|
controls_used:u32,//controls which are allowed to pass into gameplay
|
||||||
controls_mask:u32,//controls which are masked from control state (e.g. jump in scroll style)
|
controls_mask:u32,//controls which are masked from control state (e.g. jump in scroll style)
|
||||||
@ -346,7 +414,7 @@ struct StyleModifiers{
|
|||||||
surf_slope:Option<Planar64>,
|
surf_slope:Option<Planar64>,
|
||||||
rocket_force:Option<Planar64>,
|
rocket_force:Option<Planar64>,
|
||||||
gravity:Planar64Vec3,
|
gravity:Planar64Vec3,
|
||||||
hitbox_halfsize:Planar64Vec3,
|
hitbox:Hitbox,
|
||||||
camera_offset:Planar64Vec3,
|
camera_offset:Planar64Vec3,
|
||||||
}
|
}
|
||||||
impl std::default::Default for StyleModifiers{
|
impl std::default::Default for StyleModifiers{
|
||||||
@ -368,14 +436,14 @@ impl StyleModifiers{
|
|||||||
const UP_DIR:Planar64Vec3=Planar64Vec3::Y;
|
const UP_DIR:Planar64Vec3=Planar64Vec3::Y;
|
||||||
const FORWARD_DIR:Planar64Vec3=Planar64Vec3::NEG_Z;
|
const FORWARD_DIR:Planar64Vec3=Planar64Vec3::NEG_Z;
|
||||||
|
|
||||||
fn new()->Self{
|
fn neo()->Self{
|
||||||
Self{
|
Self{
|
||||||
controls_used:!0,
|
controls_used:!0,
|
||||||
controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
|
controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
|
||||||
strafe:Some(StrafeSettings{
|
strafe:Some(StrafeSettings{
|
||||||
enable:EnableStrafe::Always,
|
enable:EnableStrafe::Always,
|
||||||
air_accel_limit:None,
|
air_accel_limit:None,
|
||||||
tick_rate:Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap(),
|
tick_rate:Ratio64::new(64,Time::ONE_SECOND.nanos() as u64).unwrap(),
|
||||||
}),
|
}),
|
||||||
jump_impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
|
jump_impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
|
||||||
jump_calculation:JumpCalculation::Energy,
|
jump_calculation:JumpCalculation::Energy,
|
||||||
@ -383,7 +451,7 @@ impl StyleModifiers{
|
|||||||
static_friction:Planar64::int(2),
|
static_friction:Planar64::int(2),
|
||||||
kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
|
kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
|
||||||
mass:Planar64::int(1),
|
mass:Planar64::int(1),
|
||||||
mv:Planar64::int(2),
|
mv:Planar64::int(3),
|
||||||
rocket_force:None,
|
rocket_force:None,
|
||||||
walk_speed:Planar64::int(16),
|
walk_speed:Planar64::int(16),
|
||||||
walk_accel:Planar64::int(80),
|
walk_accel:Planar64::int(80),
|
||||||
@ -392,7 +460,7 @@ impl StyleModifiers{
|
|||||||
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
||||||
swim_speed:Planar64::int(12),
|
swim_speed:Planar64::int(12),
|
||||||
surf_slope:Some(Planar64::raw(7)/8),
|
surf_slope:Some(Planar64::raw(7)/8),
|
||||||
hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
|
hitbox:Hitbox::roblox(),
|
||||||
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -421,7 +489,7 @@ impl StyleModifiers{
|
|||||||
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
||||||
swim_speed:Planar64::int(12),
|
swim_speed:Planar64::int(12),
|
||||||
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
||||||
hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
|
hitbox:Hitbox::roblox(),
|
||||||
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -449,7 +517,7 @@ impl StyleModifiers{
|
|||||||
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
||||||
swim_speed:Planar64::int(12),
|
swim_speed:Planar64::int(12),
|
||||||
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
||||||
hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
|
hitbox:Hitbox::roblox(),
|
||||||
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -460,7 +528,7 @@ impl StyleModifiers{
|
|||||||
controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
|
controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
|
||||||
strafe:Some(StrafeSettings{
|
strafe:Some(StrafeSettings{
|
||||||
enable:EnableStrafe::Always,
|
enable:EnableStrafe::Always,
|
||||||
air_accel_limit:Some(Planar64::raw(150<<28)*66),
|
air_accel_limit:Some(Planar64::raw(150<<28)*100),
|
||||||
tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
|
tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
|
||||||
}),
|
}),
|
||||||
jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
|
jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
|
||||||
@ -478,7 +546,7 @@ impl StyleModifiers{
|
|||||||
ladder_dot:(Planar64::int(1)/2).sqrt(),//?
|
ladder_dot:(Planar64::int(1)/2).sqrt(),//?
|
||||||
swim_speed:Planar64::int(12),//?
|
swim_speed:Planar64::int(12),//?
|
||||||
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
||||||
hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
|
hitbox:Hitbox::source(),
|
||||||
camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
|
camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -506,7 +574,7 @@ impl StyleModifiers{
|
|||||||
ladder_dot:(Planar64::int(1)/2).sqrt(),//?
|
ladder_dot:(Planar64::int(1)/2).sqrt(),//?
|
||||||
swim_speed:Planar64::int(12),//?
|
swim_speed:Planar64::int(12),//?
|
||||||
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
||||||
hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
|
hitbox:Hitbox::source(),
|
||||||
camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
|
camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -530,7 +598,7 @@ impl StyleModifiers{
|
|||||||
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
ladder_dot:(Planar64::int(1)/2).sqrt(),
|
||||||
swim_speed:Planar64::int(12),
|
swim_speed:Planar64::int(12),
|
||||||
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
|
||||||
hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
|
hitbox:Hitbox::roblox(),
|
||||||
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -644,6 +712,10 @@ impl StyleModifiers{
|
|||||||
let camera_mat=camera.simulate_move_rotation(camera.mouse.lerp(&next_mouse,time));
|
let camera_mat=camera.simulate_move_rotation(camera.mouse.lerp(&next_mouse,time));
|
||||||
camera_mat*self.get_control_dir(controls)
|
camera_mat*self.get_control_dir(controls)
|
||||||
}
|
}
|
||||||
|
#[inline]
|
||||||
|
fn mesh(&self)->TransformedMesh{
|
||||||
|
self.hitbox.transformed_mesh()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
enum MoveState{
|
enum MoveState{
|
||||||
@ -655,7 +727,7 @@ enum MoveState{
|
|||||||
|
|
||||||
pub struct PhysicsState{
|
pub struct PhysicsState{
|
||||||
time:Time,
|
time:Time,
|
||||||
body:Body,
|
pub body:Body,
|
||||||
world:WorldState,//currently there is only one state the world can be in
|
world:WorldState,//currently there is only one state the world can be in
|
||||||
game:GameMechanicsState,
|
game:GameMechanicsState,
|
||||||
style:StyleModifiers,
|
style:StyleModifiers,
|
||||||
@ -666,12 +738,14 @@ pub struct PhysicsState{
|
|||||||
controls:u32,
|
controls:u32,
|
||||||
move_state:MoveState,
|
move_state:MoveState,
|
||||||
models:PhysicsModels,
|
models:PhysicsModels,
|
||||||
bvh:crate::bvh::BvhNode,
|
bvh:bvh::BvhNode,
|
||||||
|
|
||||||
modes:Modes,
|
modes:Modes,
|
||||||
//the spawn point is where you spawn when you load into the map.
|
//the spawn point is where you spawn when you load into the map.
|
||||||
//This is not the same as Reset which teleports you to Spawn0
|
//This is not the same as Reset which teleports you to Spawn0
|
||||||
spawn_point:Planar64Vec3,
|
spawn_point:Planar64Vec3,
|
||||||
|
//lmao lets go
|
||||||
|
start_time:Option<Time>,
|
||||||
}
|
}
|
||||||
#[derive(Clone,Default)]
|
#[derive(Clone,Default)]
|
||||||
pub struct PhysicsOutputState{
|
pub struct PhysicsOutputState{
|
||||||
@ -713,26 +787,26 @@ pub struct PhysicsModel{
|
|||||||
//in this iteration, all it needs is extents.
|
//in this iteration, all it needs is extents.
|
||||||
mesh_id:usize,
|
mesh_id:usize,
|
||||||
attr_id:usize,
|
attr_id:usize,
|
||||||
transform:crate::integer::Planar64Affine3,
|
transform:integer::Planar64Affine3,
|
||||||
normal_transform:crate::integer::Planar64Mat3,
|
normal_transform:integer::Planar64Mat3,
|
||||||
|
transform_det:Planar64,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl PhysicsModel{
|
impl PhysicsModel{
|
||||||
pub fn new(mesh_id:usize,attr_id:usize,transform:crate::integer::Planar64Affine3)->Self{
|
pub fn new(mesh_id:usize,attr_id:usize,transform:integer::Planar64Affine3)->Self{
|
||||||
let normal_transform=transform.matrix3.inverse().transpose();
|
|
||||||
Self{
|
Self{
|
||||||
mesh_id,
|
mesh_id,
|
||||||
attr_id,
|
attr_id,
|
||||||
transform,
|
transform,
|
||||||
normal_transform,
|
normal_transform:transform.matrix3.inverse_times_det().transpose(),
|
||||||
|
transform_det:transform.matrix3.determinant(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug,Clone,Eq,Hash,PartialEq)]
|
#[derive(Debug,Clone,Eq,Hash,PartialEq)]
|
||||||
struct ContactCollision{
|
struct ContactCollision{
|
||||||
//face_id:crate::model_physics::MinkowskiFace,
|
face_id:crate::model_physics::MinkowskiFace,
|
||||||
face_id:crate::model_physics::FaceId,
|
|
||||||
model_id:usize,//using id to avoid lifetimes
|
model_id:usize,//using id to avoid lifetimes
|
||||||
}
|
}
|
||||||
#[derive(Debug,Clone,Eq,Hash,PartialEq)]
|
#[derive(Debug,Clone,Eq,Hash,PartialEq)]
|
||||||
@ -751,7 +825,7 @@ impl Collision{
|
|||||||
|&Collision::Intersect(IntersectCollision{model_id})=>model_id,
|
|&Collision::Intersect(IntersectCollision{model_id})=>model_id,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn face_id(&self)->Option<crate::model_physics::FaceId>{
|
fn face_id(&self)->Option<crate::model_physics::MinkowskiFace>{
|
||||||
match self{
|
match self{
|
||||||
&Collision::Contact(ContactCollision{model_id:_,face_id})=>Some(face_id),
|
&Collision::Contact(ContactCollision{model_id:_,face_id})=>Some(face_id),
|
||||||
&Collision::Intersect(IntersectCollision{model_id:_})=>None,
|
&Collision::Intersect(IntersectCollision{model_id:_})=>None,
|
||||||
@ -811,20 +885,20 @@ impl TouchingState{
|
|||||||
//add water../?
|
//add water../?
|
||||||
a
|
a
|
||||||
}
|
}
|
||||||
fn constrain_velocity(&self,models:&PhysicsModels,velocity:&mut Planar64Vec3){
|
fn constrain_velocity(&self,models:&PhysicsModels,style_mesh:&TransformedMesh,velocity:&mut Planar64Vec3){
|
||||||
//TODO: trey push solve
|
//TODO: trey push solve
|
||||||
for contact in &self.contacts{
|
for contact in &self.contacts{
|
||||||
let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let n=contact_normal(models,style_mesh,contact);
|
||||||
let d=n.dot128(*velocity);
|
let d=n.dot128(*velocity);
|
||||||
if d<0{
|
if d<0{
|
||||||
*velocity-=n*Planar64::raw(((d<<32)/n.dot128(n)) as i64);
|
*velocity-=n*Planar64::raw(((d<<32)/n.dot128(n)) as i64);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn constrain_acceleration(&self,models:&PhysicsModels,acceleration:&mut Planar64Vec3){
|
fn constrain_acceleration(&self,models:&PhysicsModels,style_mesh:&TransformedMesh,acceleration:&mut Planar64Vec3){
|
||||||
//TODO: trey push solve
|
//TODO: trey push solve
|
||||||
for contact in &self.contacts{
|
for contact in &self.contacts{
|
||||||
let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let n=contact_normal(models,style_mesh,contact);
|
||||||
let d=n.dot128(*acceleration);
|
let d=n.dot128(*acceleration);
|
||||||
if d<0{
|
if d<0{
|
||||||
*acceleration-=n*Planar64::raw(((d<<32)/n.dot128(n)) as i64);
|
*acceleration-=n*Planar64::raw(((d<<32)/n.dot128(n)) as i64);
|
||||||
@ -835,30 +909,31 @@ impl TouchingState{
|
|||||||
//check current move conditions and use heuristics to determine
|
//check current move conditions and use heuristics to determine
|
||||||
//which ladder to climb on, which ground to walk on, etc
|
//which ladder to climb on, which ground to walk on, etc
|
||||||
//collect move state affecting objects from contacts (accelerator,water,ladder,ground)
|
//collect move state affecting objects from contacts (accelerator,water,ladder,ground)
|
||||||
|
let style_mesh=style.mesh();
|
||||||
let gravity=self.base_acceleration(models,style,camera,controls,next_mouse,time);
|
let gravity=self.base_acceleration(models,style,camera,controls,next_mouse,time);
|
||||||
let mut move_state=MoveState::Air;
|
let mut move_state=MoveState::Air;
|
||||||
let mut a=gravity;
|
let mut a=gravity;
|
||||||
for contact in &self.contacts{
|
for contact in &self.contacts{
|
||||||
match models.attr(contact.model_id){
|
match models.attr(contact.model_id){
|
||||||
PhysicsCollisionAttributes::Contact{contacting,general}=>{
|
PhysicsCollisionAttributes::Contact{contacting,general}=>{
|
||||||
let normal=models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let normal=contact_normal(models,&style_mesh,contact);
|
||||||
match &contacting.contact_behaviour{
|
match &contacting.contact_behaviour{
|
||||||
Some(crate::model::ContactingBehaviour::Ladder(_))=>{
|
Some(crate::model::ContactingBehaviour::Ladder(_))=>{
|
||||||
//ladder walkstate
|
//ladder walkstate
|
||||||
let mut target_velocity=style.get_ladder_target_velocity(camera,controls,next_mouse,time,&normal);
|
let mut target_velocity=style.get_ladder_target_velocity(camera,controls,next_mouse,time,&normal);
|
||||||
self.constrain_velocity(models,&mut target_velocity);
|
self.constrain_velocity(models,&style_mesh,&mut target_velocity);
|
||||||
let (walk_state,mut acceleration)=WalkState::ladder(body,style,gravity,target_velocity,contact.clone(),&normal);
|
let (walk_state,mut acceleration)=WalkState::ladder(body,style,gravity,target_velocity,contact.clone(),&normal);
|
||||||
move_state=MoveState::Ladder(walk_state);
|
move_state=MoveState::Ladder(walk_state);
|
||||||
self.constrain_acceleration(models,&mut acceleration);
|
self.constrain_acceleration(models,&style_mesh,&mut acceleration);
|
||||||
a=acceleration;
|
a=acceleration;
|
||||||
},
|
},
|
||||||
None=>if style.surf_slope.map_or(true,|s|normal.walkable(s,Planar64Vec3::Y)){
|
None=>if style.surf_slope.map_or(true,|s|normal.walkable(s,Planar64Vec3::Y)){
|
||||||
//check ground
|
//check ground
|
||||||
let mut target_velocity=style.get_walk_target_velocity(camera,controls,next_mouse,time,&normal);
|
let mut target_velocity=style.get_walk_target_velocity(camera,controls,next_mouse,time,&normal);
|
||||||
self.constrain_velocity(models,&mut target_velocity);
|
self.constrain_velocity(models,&style_mesh,&mut target_velocity);
|
||||||
let (walk_state,mut acceleration)=WalkState::ground(body,style,gravity,target_velocity,contact.clone(),&normal);
|
let (walk_state,mut acceleration)=WalkState::ground(body,style,gravity,target_velocity,contact.clone(),&normal);
|
||||||
move_state=MoveState::Walk(walk_state);
|
move_state=MoveState::Walk(walk_state);
|
||||||
self.constrain_acceleration(models,&mut acceleration);
|
self.constrain_acceleration(models,&style_mesh,&mut acceleration);
|
||||||
a=acceleration;
|
a=acceleration;
|
||||||
},
|
},
|
||||||
_=>(),
|
_=>(),
|
||||||
@ -868,15 +943,18 @@ impl TouchingState{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
for intersect in &self.intersects{
|
for intersect in &self.intersects{
|
||||||
//
|
//water
|
||||||
}
|
}
|
||||||
self.constrain_acceleration(models,&mut a);
|
self.constrain_acceleration(models,&style_mesh,&mut a);
|
||||||
(move_state,a)
|
(move_state,a)
|
||||||
}
|
}
|
||||||
fn predict_collision_end(&self,collector:&mut crate::instruction::InstructionCollector<PhysicsInstruction>,models:&PhysicsModels,body:&Body,time:Time){
|
fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<PhysicsInstruction>,models:&PhysicsModels,style_mesh:&TransformedMesh,body:&Body,time:Time){
|
||||||
|
let relative_body=VirtualBody::relative(&Body::default(),body).body(time);
|
||||||
for contact in &self.contacts{
|
for contact in &self.contacts{
|
||||||
//detect face slide off
|
//detect face slide off
|
||||||
collector.collect(models.mesh(contact.model_id).brute_out_face(body,collector.time(),contact.face_id).map(|(face,time)|{
|
let model_mesh=models.mesh(contact.model_id);
|
||||||
|
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
|
||||||
|
collector.collect(minkowski.predict_collision_face_out(&relative_body,collector.time(),contact.face_id).map(|(face,time)|{
|
||||||
TimedInstruction{
|
TimedInstruction{
|
||||||
time,
|
time,
|
||||||
instruction:PhysicsInstruction::CollisionEnd(
|
instruction:PhysicsInstruction::CollisionEnd(
|
||||||
@ -885,10 +963,11 @@ impl TouchingState{
|
|||||||
}
|
}
|
||||||
}));
|
}));
|
||||||
}
|
}
|
||||||
let relative_body=VirtualBody::relative(&Body::default(),body).body(time);
|
|
||||||
for intersect in &self.intersects{
|
for intersect in &self.intersects{
|
||||||
//detect model collision in reverse
|
//detect model collision in reverse
|
||||||
collector.collect(models.mesh(intersect.model_id).brute_out(&relative_body,collector.time()).map(|(face,time)|{
|
let model_mesh=models.mesh(intersect.model_id);
|
||||||
|
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
|
||||||
|
collector.collect(minkowski.predict_collision_out(&relative_body,collector.time()).map(|(face,time)|{
|
||||||
TimedInstruction{
|
TimedInstruction{
|
||||||
time,
|
time,
|
||||||
instruction:PhysicsInstruction::CollisionEnd(
|
instruction:PhysicsInstruction::CollisionEnd(
|
||||||
@ -922,6 +1001,42 @@ impl Body{
|
|||||||
self.velocity=self.extrapolated_velocity(time);
|
self.velocity=self.extrapolated_velocity(time);
|
||||||
self.time=time;
|
self.time=time;
|
||||||
}
|
}
|
||||||
|
pub fn infinity_dir(&self)->Option<Planar64Vec3>{
|
||||||
|
if self.velocity==Planar64Vec3::ZERO{
|
||||||
|
if self.acceleration==Planar64Vec3::ZERO{
|
||||||
|
None
|
||||||
|
}else{
|
||||||
|
Some(self.acceleration)
|
||||||
|
}
|
||||||
|
}else{
|
||||||
|
Some(self.velocity)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn grow_aabb(&self,aabb:&mut aabb::Aabb,t0:Time,t1:Time){
|
||||||
|
aabb.grow(self.extrapolated_position(t0));
|
||||||
|
aabb.grow(self.extrapolated_position(t1));
|
||||||
|
//v+a*t==0
|
||||||
|
//goober code
|
||||||
|
if self.acceleration.x()!=Planar64::ZERO{
|
||||||
|
let t=Time::from(-self.velocity.x()/self.acceleration.x());
|
||||||
|
if t0<t&&t<t1{
|
||||||
|
aabb.grow(self.extrapolated_position(t));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if self.acceleration.y()!=Planar64::ZERO{
|
||||||
|
let t=Time::from(-self.velocity.y()/self.acceleration.y());
|
||||||
|
if t0<t&&t<t1{
|
||||||
|
aabb.grow(self.extrapolated_position(t));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if self.acceleration.z()!=Planar64::ZERO{
|
||||||
|
let t=Time::from(-self.velocity.z()/self.acceleration.z());
|
||||||
|
if t0<t&&t<t1{
|
||||||
|
aabb.grow(self.extrapolated_position(t));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
impl std::fmt::Display for Body{
|
impl std::fmt::Display for Body{
|
||||||
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
@ -965,7 +1080,7 @@ impl Default for PhysicsState{
|
|||||||
style:StyleModifiers::default(),
|
style:StyleModifiers::default(),
|
||||||
touching:TouchingState::default(),
|
touching:TouchingState::default(),
|
||||||
models:PhysicsModels::default(),
|
models:PhysicsModels::default(),
|
||||||
bvh:crate::bvh::BvhNode::default(),
|
bvh:bvh::BvhNode::default(),
|
||||||
move_state: MoveState::Air,
|
move_state: MoveState::Air,
|
||||||
camera:PhysicsCamera::default(),
|
camera:PhysicsCamera::default(),
|
||||||
next_mouse:MouseState::default(),
|
next_mouse:MouseState::default(),
|
||||||
@ -973,6 +1088,7 @@ impl Default for PhysicsState{
|
|||||||
world:WorldState{},
|
world:WorldState{},
|
||||||
game:GameMechanicsState::default(),
|
game:GameMechanicsState::default(),
|
||||||
modes:Modes::default(),
|
modes:Modes::default(),
|
||||||
|
start_time:None,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -982,7 +1098,7 @@ impl PhysicsState {
|
|||||||
self.models.clear();
|
self.models.clear();
|
||||||
self.modes.clear();
|
self.modes.clear();
|
||||||
self.touching.clear();
|
self.touching.clear();
|
||||||
self.bvh=crate::bvh::BvhNode::default();
|
self.bvh=bvh::BvhNode::default();
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn output(&self)->PhysicsOutputState{
|
pub fn output(&self)->PhysicsOutputState{
|
||||||
@ -996,7 +1112,7 @@ impl PhysicsState {
|
|||||||
pub fn spawn(&mut self,spawn_point:Planar64Vec3){
|
pub fn spawn(&mut self,spawn_point:Planar64Vec3){
|
||||||
self.game.stage_id=0;
|
self.game.stage_id=0;
|
||||||
self.spawn_point=spawn_point;
|
self.spawn_point=spawn_point;
|
||||||
self.process_instruction(crate::instruction::TimedInstruction{
|
self.process_instruction(instruction::TimedInstruction{
|
||||||
time:self.time,
|
time:self.time,
|
||||||
instruction: PhysicsInstruction::Input(PhysicsInputInstruction::Reset),
|
instruction: PhysicsInstruction::Input(PhysicsInputInstruction::Reset),
|
||||||
});
|
});
|
||||||
@ -1034,7 +1150,7 @@ impl PhysicsState {
|
|||||||
self.models.push_mesh(PhysicsMesh::from(model));
|
self.models.push_mesh(PhysicsMesh::from(model));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
self.bvh=crate::bvh::generate_bvh(self.models.aabb_list());
|
self.bvh=bvh::generate_bvh(self.models.aabb_list());
|
||||||
//I don't wanna write structs for temporary structures
|
//I don't wanna write structs for temporary structures
|
||||||
//this code builds ModeDescriptions from the unsorted lists at the top of the function
|
//this code builds ModeDescriptions from the unsorted lists at the top of the function
|
||||||
starts.sort_by_key(|tup|tup.1.mode_id);
|
starts.sort_by_key(|tup|tup.1.mode_id);
|
||||||
@ -1132,21 +1248,23 @@ impl PhysicsState {
|
|||||||
match &mut self.move_state{
|
match &mut self.move_state{
|
||||||
MoveState::Air|MoveState::Water=>self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time),
|
MoveState::Air|MoveState::Water=>self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time),
|
||||||
MoveState::Walk(WalkState{state,contact,jump_direction:_})=>{
|
MoveState::Walk(WalkState{state,contact,jump_direction:_})=>{
|
||||||
let n=self.models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let style_mesh=self.style.mesh();
|
||||||
|
let n=contact_normal(&self.models,&style_mesh,contact);
|
||||||
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
let mut a;
|
let mut a;
|
||||||
let mut v=self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&n);
|
let mut v=self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&n);
|
||||||
self.touching.constrain_velocity(&self.models,&mut v);
|
self.touching.constrain_velocity(&self.models,&style_mesh,&mut v);
|
||||||
let normal_accel=-n.dot(gravity)/n.length();
|
let normal_accel=-n.dot(gravity)/n.length();
|
||||||
(*state,a)=WalkEnum::with_target_velocity(&self.body,&self.style,v,&n,self.style.walk_speed,normal_accel);
|
(*state,a)=WalkEnum::with_target_velocity(&self.body,&self.style,v,&n,self.style.walk_speed,normal_accel);
|
||||||
a
|
a
|
||||||
},
|
},
|
||||||
MoveState::Ladder(WalkState{state,contact,jump_direction:_})=>{
|
MoveState::Ladder(WalkState{state,contact,jump_direction:_})=>{
|
||||||
let n=self.models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let style_mesh=self.style.mesh();
|
||||||
|
let n=contact_normal(&self.models,&style_mesh,contact);
|
||||||
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
let mut a;
|
let mut a;
|
||||||
let mut v=self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&n);
|
let mut v=self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&n);
|
||||||
self.touching.constrain_velocity(&self.models,&mut v);
|
self.touching.constrain_velocity(&self.models,&style_mesh,&mut v);
|
||||||
(*state,a)=WalkEnum::with_target_velocity(&self.body,&self.style,v,&n,self.style.ladder_speed,self.style.ladder_accel);
|
(*state,a)=WalkEnum::with_target_velocity(&self.body,&self.style,v,&n,self.style.ladder_speed,self.style.ladder_accel);
|
||||||
a
|
a
|
||||||
},
|
},
|
||||||
@ -1168,28 +1286,31 @@ impl PhysicsState {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState{
|
impl instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState{
|
||||||
//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
|
//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
|
||||||
fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<PhysicsInstruction>>{
|
fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<PhysicsInstruction>>{
|
||||||
//JUST POLLING!!! NO MUTATION
|
//JUST POLLING!!! NO MUTATION
|
||||||
let mut collector = crate::instruction::InstructionCollector::new(time_limit);
|
let mut collector = instruction::InstructionCollector::new(time_limit);
|
||||||
|
|
||||||
collector.collect(self.next_move_instruction());
|
collector.collect(self.next_move_instruction());
|
||||||
|
|
||||||
|
let style_mesh=self.style.mesh();
|
||||||
//check for collision ends
|
//check for collision ends
|
||||||
self.touching.predict_collision_end(&mut collector,&self.models,&self.body,self.time);
|
self.touching.predict_collision_end(&mut collector,&self.models,&style_mesh,&self.body,self.time);
|
||||||
//check for collision starts
|
//check for collision starts
|
||||||
let mut aabb=crate::aabb::Aabb::default();
|
let mut aabb=aabb::Aabb::default();
|
||||||
aabb.grow(self.body.extrapolated_position(self.time));
|
self.body.grow_aabb(&mut aabb,self.time,collector.time());
|
||||||
aabb.grow(self.body.extrapolated_position(collector.time()));
|
aabb.inflate(self.style.hitbox.halfsize);
|
||||||
aabb.inflate(self.style.hitbox_halfsize);
|
|
||||||
//common body
|
//common body
|
||||||
let relative_body=VirtualBody::relative(&Body::default(),&self.body).body(self.time);
|
let relative_body=VirtualBody::relative(&Body::default(),&self.body).body(self.time);
|
||||||
self.bvh.the_tester(&aabb,&mut |id|{
|
self.bvh.the_tester(&aabb,&mut |id|{
|
||||||
//no checks are needed because of the time limits.
|
//no checks are needed because of the time limits.
|
||||||
//let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(self.style.mesh,&self.models.mesh(id));
|
let model_mesh=self.models.mesh(id);
|
||||||
//collector.collect(crate::face_crawler::predict_collision(&minkowski,&relative_body,collector.time()).map(|(face,time)|{
|
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
|
||||||
collector.collect(self.models.mesh(id).brute_in(&relative_body,collector.time()).map(|(face,time)|{
|
collector.collect(minkowski.predict_collision_in(&relative_body,collector.time())
|
||||||
|
//temp (?) code to avoid collision loops
|
||||||
|
.map_or(None,|(face,time)|if time==self.time{None}else{Some((face,time))})
|
||||||
|
.map(|(face,time)|{
|
||||||
TimedInstruction{time,instruction:PhysicsInstruction::CollisionStart(match self.models.attr(id){
|
TimedInstruction{time,instruction:PhysicsInstruction::CollisionStart(match self.models.attr(id){
|
||||||
PhysicsCollisionAttributes::Contact{contacting:_,general:_}=>Collision::Contact(ContactCollision{model_id:id,face_id:face}),
|
PhysicsCollisionAttributes::Contact{contacting:_,general:_}=>Collision::Contact(ContactCollision{model_id:id,face_id:face}),
|
||||||
PhysicsCollisionAttributes::Intersect{intersecting:_,general:_}=>Collision::Intersect(IntersectCollision{model_id:id}),
|
PhysicsCollisionAttributes::Intersect{intersecting:_,general:_}=>Collision::Intersect(IntersectCollision{model_id:id}),
|
||||||
@ -1209,12 +1330,18 @@ fn get_walk_state(move_state:&MoveState)->Option<&WalkState>{
|
|||||||
|
|
||||||
fn jumped_velocity(models:&PhysicsModels,style:&StyleModifiers,walk_state:&WalkState,v:&mut Planar64Vec3){
|
fn jumped_velocity(models:&PhysicsModels,style:&StyleModifiers,walk_state:&WalkState,v:&mut Planar64Vec3){
|
||||||
let jump_dir=match &walk_state.jump_direction{
|
let jump_dir=match &walk_state.jump_direction{
|
||||||
JumpDirection::FromContactNormal=>models.mesh(walk_state.contact.model_id).face_nd(walk_state.contact.face_id).0,
|
JumpDirection::FromContactNormal=>contact_normal(models,&style.mesh(),&walk_state.contact),
|
||||||
&JumpDirection::Exactly(dir)=>dir,
|
&JumpDirection::Exactly(dir)=>dir,
|
||||||
};
|
};
|
||||||
*v=*v+jump_dir*(style.get_jump_deltav()/jump_dir.length());
|
*v=*v+jump_dir*(style.get_jump_deltav()/jump_dir.length());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn contact_normal(models:&PhysicsModels,style_mesh:&TransformedMesh,contact:&ContactCollision)->Planar64Vec3{
|
||||||
|
let model_mesh=models.mesh(contact.model_id);
|
||||||
|
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,style_mesh);
|
||||||
|
minkowski.face_nd(contact.face_id).0
|
||||||
|
}
|
||||||
|
|
||||||
fn set_position(body:&mut Body,touching:&mut TouchingState,point:Planar64Vec3)->Planar64Vec3{
|
fn set_position(body:&mut Body,touching:&mut TouchingState,point:Planar64Vec3)->Planar64Vec3{
|
||||||
//test intersections at new position
|
//test intersections at new position
|
||||||
//hovering above the surface 0 units is not intersecting. you will fall into it just fine
|
//hovering above the surface 0 units is not intersecting. you will fall into it just fine
|
||||||
@ -1225,11 +1352,11 @@ fn set_position(body:&mut Body,touching:&mut TouchingState,point:Planar64Vec3)->
|
|||||||
//touching.recalculate(body);
|
//touching.recalculate(body);
|
||||||
point
|
point
|
||||||
}
|
}
|
||||||
fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,v:Planar64Vec3)->bool{
|
fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,v:Planar64Vec3)->bool{
|
||||||
//This is not correct but is better than what I have
|
//This is not correct but is better than what I have
|
||||||
let mut culled=false;
|
let mut culled=false;
|
||||||
touching.contacts.retain(|contact|{
|
touching.contacts.retain(|contact|{
|
||||||
let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let n=contact_normal(models,style_mesh,contact);
|
||||||
let r=n.dot(v)<=Planar64::ZERO;
|
let r=n.dot(v)<=Planar64::ZERO;
|
||||||
if !r{
|
if !r{
|
||||||
culled=true;
|
culled=true;
|
||||||
@ -1237,19 +1364,19 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
|
|||||||
}
|
}
|
||||||
r
|
r
|
||||||
});
|
});
|
||||||
set_velocity(body,touching,models,v);
|
set_velocity(body,touching,models,style_mesh,v);
|
||||||
culled
|
culled
|
||||||
}
|
}
|
||||||
fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,mut v:Planar64Vec3)->Planar64Vec3{
|
fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,mut v:Planar64Vec3)->Planar64Vec3{
|
||||||
touching.constrain_velocity(&models,&mut v);
|
touching.constrain_velocity(models,style_mesh,&mut v);
|
||||||
body.velocity=v;
|
body.velocity=v;
|
||||||
v
|
v
|
||||||
}
|
}
|
||||||
fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,a:Planar64Vec3)->bool{
|
fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,a:Planar64Vec3)->bool{
|
||||||
//This is not correct but is better than what I have
|
//This is not correct but is better than what I have
|
||||||
let mut culled=false;
|
let mut culled=false;
|
||||||
touching.contacts.retain(|contact|{
|
touching.contacts.retain(|contact|{
|
||||||
let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
let n=contact_normal(models,style_mesh,contact);
|
||||||
let r=n.dot(a)<=Planar64::ZERO;
|
let r=n.dot(a)<=Planar64::ZERO;
|
||||||
if !r{
|
if !r{
|
||||||
culled=true;
|
culled=true;
|
||||||
@ -1257,23 +1384,23 @@ fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&Phys
|
|||||||
}
|
}
|
||||||
r
|
r
|
||||||
});
|
});
|
||||||
set_acceleration(body,touching,models,a);
|
set_acceleration(body,touching,models,style_mesh,a);
|
||||||
culled
|
culled
|
||||||
}
|
}
|
||||||
fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,mut a:Planar64Vec3)->Planar64Vec3{
|
fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,mut a:Planar64Vec3)->Planar64Vec3{
|
||||||
touching.constrain_acceleration(&models,&mut a);
|
touching.constrain_acceleration(models,style_mesh,&mut a);
|
||||||
body.acceleration=a;
|
body.acceleration=a;
|
||||||
a
|
a
|
||||||
}
|
}
|
||||||
|
|
||||||
fn teleport(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style:&StyleModifiers,point:Planar64Vec3)->MoveState{
|
fn teleport(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style:&StyleModifiers,point:Planar64Vec3)->MoveState{
|
||||||
set_position(body,touching,point);
|
set_position(body,touching,point);
|
||||||
set_acceleration(body,touching,models,style.gravity);
|
set_acceleration(body,touching,models,&style.mesh(),style.gravity);
|
||||||
MoveState::Air
|
MoveState::Air
|
||||||
}
|
}
|
||||||
fn teleport_to_spawn(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,mode:&crate::model::ModeDescription,models:&PhysicsModels,stage_id:u32)->Option<MoveState>{
|
fn teleport_to_spawn(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,mode:&crate::model::ModeDescription,models:&PhysicsModels,stage_id:u32)->Option<MoveState>{
|
||||||
let model=models.model(*mode.get_spawn_model_id(stage_id)? as usize);
|
let model=models.model(*mode.get_spawn_model_id(stage_id)? as usize);
|
||||||
let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox_halfsize.y()+Planar64::ONE/16);
|
let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox.halfsize.y()+Planar64::ONE/16);
|
||||||
Some(teleport(body,touching,models,style,point))
|
Some(teleport(body,touching,models,style,point))
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1342,7 +1469,7 @@ fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehav
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
|
impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
|
||||||
fn process_instruction(&mut self, ins:TimedInstruction<PhysicsInstruction>) {
|
fn process_instruction(&mut self, ins:TimedInstruction<PhysicsInstruction>) {
|
||||||
match &ins.instruction{
|
match &ins.instruction{
|
||||||
PhysicsInstruction::Input(PhysicsInputInstruction::Idle)
|
PhysicsInstruction::Input(PhysicsInputInstruction::Idle)
|
||||||
@ -1362,41 +1489,42 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
}
|
}
|
||||||
match ins.instruction{
|
match ins.instruction{
|
||||||
PhysicsInstruction::CollisionStart(c)=>{
|
PhysicsInstruction::CollisionStart(c)=>{
|
||||||
|
let style_mesh=self.style.mesh();
|
||||||
let model_id=c.model_id();
|
let model_id=c.model_id();
|
||||||
match (self.models.attr(model_id),&c){
|
match (self.models.attr(model_id),&c){
|
||||||
(PhysicsCollisionAttributes::Contact{contacting,general},Collision::Contact(contact))=>{
|
(PhysicsCollisionAttributes::Contact{contacting,general},Collision::Contact(contact))=>{
|
||||||
let mut v=self.body.velocity;
|
let mut v=self.body.velocity;
|
||||||
let normal=self.models.mesh(model_id).face_nd(contact.face_id).0;
|
let normal=contact_normal(&self.models,&style_mesh,contact);
|
||||||
match &contacting.contact_behaviour{
|
match &contacting.contact_behaviour{
|
||||||
Some(crate::model::ContactingBehaviour::Surf)=>println!("I'm surfing!"),
|
Some(crate::model::ContactingBehaviour::Surf)=>println!("I'm surfing!"),
|
||||||
Some(crate::model::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
|
Some(crate::model::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
|
||||||
&Some(crate::model::ContactingBehaviour::Elastic(elasticity))=>{
|
&Some(crate::model::ContactingBehaviour::Elastic(elasticity))=>{
|
||||||
let n=self.models.mesh(contact.model_id).face_nd(contact.face_id).0;
|
|
||||||
//velocity and normal are facing opposite directions so this is inherently negative.
|
//velocity and normal are facing opposite directions so this is inherently negative.
|
||||||
let d=n.dot(v)*(Planar64::ONE+Planar64::raw(elasticity as i64+1));
|
let d=normal.dot(v)*(Planar64::ONE+Planar64::raw(elasticity as i64+1));
|
||||||
v+=n*(d/n.dot(n));
|
v+=normal*(d/normal.dot(normal));
|
||||||
},
|
},
|
||||||
Some(crate::model::ContactingBehaviour::Ladder(contacting_ladder))=>{
|
Some(crate::model::ContactingBehaviour::Ladder(contacting_ladder))=>{
|
||||||
if contacting_ladder.sticky{
|
if contacting_ladder.sticky{
|
||||||
//kill v
|
//kill v
|
||||||
|
//actually you could do this with a booster attribute :thinking:
|
||||||
v=Planar64Vec3::ZERO;//model.velocity
|
v=Planar64Vec3::ZERO;//model.velocity
|
||||||
}
|
}
|
||||||
//ladder walkstate
|
//ladder walkstate
|
||||||
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
let mut target_velocity=self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&normal);
|
let mut target_velocity=self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&normal);
|
||||||
self.touching.constrain_velocity(&self.models,&mut target_velocity);
|
self.touching.constrain_velocity(&self.models,&style_mesh,&mut target_velocity);
|
||||||
let (walk_state,a)=WalkState::ladder(&self.body,&self.style,gravity,target_velocity,contact.clone(),&normal);
|
let (walk_state,a)=WalkState::ladder(&self.body,&self.style,gravity,target_velocity,contact.clone(),&normal);
|
||||||
self.move_state=MoveState::Ladder(walk_state);
|
self.move_state=MoveState::Ladder(walk_state);
|
||||||
set_acceleration(&mut self.body,&self.touching,&self.models,a);
|
set_acceleration(&mut self.body,&self.touching,&self.models,&style_mesh,a);
|
||||||
}
|
}
|
||||||
None=>if self.style.surf_slope.map_or(true,|s|self.models.mesh(model_id).face_nd(contact.face_id).0.walkable(s,Planar64Vec3::Y)){
|
None=>if self.style.surf_slope.map_or(true,|s|contact_normal(&self.models,&style_mesh,contact).walkable(s,Planar64Vec3::Y)){
|
||||||
//ground
|
//ground
|
||||||
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
let mut target_velocity=self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&normal);
|
let mut target_velocity=self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&normal);
|
||||||
self.touching.constrain_velocity(&self.models,&mut target_velocity);
|
self.touching.constrain_velocity(&self.models,&style_mesh,&mut target_velocity);
|
||||||
let (walk_state,a)=WalkState::ground(&self.body,&self.style,gravity,target_velocity,contact.clone(),&normal);
|
let (walk_state,a)=WalkState::ground(&self.body,&self.style,gravity,target_velocity,contact.clone(),&normal);
|
||||||
self.move_state=MoveState::Walk(walk_state);
|
self.move_state=MoveState::Walk(walk_state);
|
||||||
set_acceleration(&mut self.body,&self.touching,&self.models,a);
|
set_acceleration(&mut self.body,&self.touching,&self.models,&style_mesh,a);
|
||||||
},
|
},
|
||||||
}
|
}
|
||||||
//check ground
|
//check ground
|
||||||
@ -1404,7 +1532,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
//I love making functions with 10 arguments to dodge the borrow checker
|
//I love making functions with 10 arguments to dodge the borrow checker
|
||||||
run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model_id);
|
run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model_id);
|
||||||
//flatten v
|
//flatten v
|
||||||
self.touching.constrain_velocity(&self.models,&mut v);
|
self.touching.constrain_velocity(&self.models,&style_mesh,&mut v);
|
||||||
match &general.booster{
|
match &general.booster{
|
||||||
Some(booster)=>{
|
Some(booster)=>{
|
||||||
//DELETE THIS when boosters get converted to height machines
|
//DELETE THIS when boosters get converted to height machines
|
||||||
@ -1419,7 +1547,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
let calc_move=if self.style.get_control(StyleModifiers::CONTROL_JUMP,self.controls){
|
let calc_move=if self.style.get_control(StyleModifiers::CONTROL_JUMP,self.controls){
|
||||||
if let Some(walk_state)=get_walk_state(&self.move_state){
|
if let Some(walk_state)=get_walk_state(&self.move_state){
|
||||||
jumped_velocity(&self.models,&self.style,walk_state,&mut v);
|
jumped_velocity(&self.models,&self.style,walk_state,&mut v);
|
||||||
set_velocity_cull(&mut self.body,&mut self.touching,&self.models,v)
|
set_velocity_cull(&mut self.body,&mut self.touching,&self.models,&style_mesh,v)
|
||||||
}else{false}
|
}else{false}
|
||||||
}else{false};
|
}else{false};
|
||||||
match &general.trajectory{
|
match &general.trajectory{
|
||||||
@ -1435,15 +1563,30 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
},
|
},
|
||||||
None=>(),
|
None=>(),
|
||||||
}
|
}
|
||||||
set_velocity(&mut self.body,&self.touching,&self.models,v);
|
set_velocity(&mut self.body,&self.touching,&self.models,&style_mesh,v);
|
||||||
//not sure if or is correct here
|
//not sure if or is correct here
|
||||||
if calc_move||Planar64::ZERO<normal.dot(v){
|
if calc_move||Planar64::ZERO<normal.dot(v){
|
||||||
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
}
|
}
|
||||||
let a=self.refresh_walk_target();
|
let a=self.refresh_walk_target();
|
||||||
set_acceleration(&mut self.body,&self.touching,&self.models,a);
|
set_acceleration(&mut self.body,&self.touching,&self.models,&self.style.mesh(),a);
|
||||||
},
|
},
|
||||||
(PhysicsCollisionAttributes::Intersect{intersecting: _,general},Collision::Intersect(intersect))=>{
|
(PhysicsCollisionAttributes::Intersect{intersecting: _,general},Collision::Intersect(intersect))=>{
|
||||||
|
//check for mapstart and set start time
|
||||||
|
let model_id=c.model_id();
|
||||||
|
let start_model_id=self.modes.get_mode(0).unwrap().start;
|
||||||
|
if model_id==start_model_id{
|
||||||
|
//object touched is a mapstart
|
||||||
|
println!("Start!");
|
||||||
|
self.start_time=Some(self.time);
|
||||||
|
}
|
||||||
|
|
||||||
|
//check for map finish and print end time
|
||||||
|
if general.zone.as_ref().is_some_and(|zone|zone.behaviour==crate::model::ZoneBehaviour::Finish){
|
||||||
|
if let Some(start_time)=self.start_time.take(){
|
||||||
|
println!("Finish! Time={}",self.time-start_time);
|
||||||
|
}
|
||||||
|
}
|
||||||
//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
|
//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
|
||||||
self.touching.insert(c);
|
self.touching.insert(c);
|
||||||
run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model_id);
|
run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model_id);
|
||||||
@ -1474,7 +1617,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
let v=self.body.velocity+control_dir*(self.style.mv-d);
|
let v=self.body.velocity+control_dir*(self.style.mv-d);
|
||||||
//this is wrong but will work ig
|
//this is wrong but will work ig
|
||||||
//need to note which push planes activate in push solve and keep those
|
//need to note which push planes activate in push solve and keep those
|
||||||
if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,v){
|
if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,&self.style.mesh(),v){
|
||||||
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1487,11 +1630,12 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
match &mut walk_state.state{
|
match &mut walk_state.state{
|
||||||
WalkEnum::Reached=>(),
|
WalkEnum::Reached=>(),
|
||||||
WalkEnum::Transient(walk_target)=>{
|
WalkEnum::Transient(walk_target)=>{
|
||||||
|
let style_mesh=self.style.mesh();
|
||||||
//precisely set velocity
|
//precisely set velocity
|
||||||
let a=Planar64Vec3::ZERO;//ignore gravity for now.
|
let a=Planar64Vec3::ZERO;//ignore gravity for now.
|
||||||
set_acceleration(&mut self.body,&self.touching,&self.models,a);
|
set_acceleration(&mut self.body,&self.touching,&self.models,&style_mesh,a);
|
||||||
let v=walk_target.velocity;
|
let v=walk_target.velocity;
|
||||||
set_velocity(&mut self.body,&self.touching,&self.models,v);
|
set_velocity(&mut self.body,&self.touching,&self.models,&style_mesh,v);
|
||||||
walk_state.state=WalkEnum::Reached;
|
walk_state.state=WalkEnum::Reached;
|
||||||
},
|
},
|
||||||
}
|
}
|
||||||
@ -1520,7 +1664,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
if let Some(walk_state)=get_walk_state(&self.move_state){
|
if let Some(walk_state)=get_walk_state(&self.move_state){
|
||||||
let mut v=self.body.velocity;
|
let mut v=self.body.velocity;
|
||||||
jumped_velocity(&self.models,&self.style,walk_state,&mut v);
|
jumped_velocity(&self.models,&self.style,walk_state,&mut v);
|
||||||
if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,v){
|
if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,&self.style.mesh(),v){
|
||||||
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1533,7 +1677,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
PhysicsInputInstruction::Reset => {
|
PhysicsInputInstruction::Reset => {
|
||||||
//it matters which of these runs first, but I have not thought it through yet as it doesn't matter yet
|
//it matters which of these runs first, but I have not thought it through yet as it doesn't matter yet
|
||||||
set_position(&mut self.body,&mut self.touching,self.spawn_point);
|
set_position(&mut self.body,&mut self.touching,self.spawn_point);
|
||||||
set_velocity(&mut self.body,&self.touching,&self.models,Planar64Vec3::ZERO);
|
set_velocity(&mut self.body,&self.touching,&self.models,&self.style.mesh(),Planar64Vec3::ZERO);
|
||||||
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
refresh_walk_target=false;
|
refresh_walk_target=false;
|
||||||
},
|
},
|
||||||
@ -1541,7 +1685,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
}
|
}
|
||||||
if refresh_walk_target{
|
if refresh_walk_target{
|
||||||
let a=self.refresh_walk_target();
|
let a=self.refresh_walk_target();
|
||||||
if set_acceleration_cull(&mut self.body,&mut self.touching,&self.models,a){
|
if set_acceleration_cull(&mut self.body,&mut self.touching,&self.models,&self.style.mesh(),a){
|
||||||
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1549,3 +1693,218 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
|
||||||
|
let h0=Hitbox::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cube()),Planar64Vec3::int(5,1,5)/2);
|
||||||
|
let h1=Hitbox::roblox();
|
||||||
|
let hitbox_mesh=h1.transformed_mesh();
|
||||||
|
let platform_mesh=h0.transformed_mesh();
|
||||||
|
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&platform_mesh,&hitbox_mesh);
|
||||||
|
let collision=minkowski.predict_collision_in(&relative_body,Time::MAX);
|
||||||
|
assert_eq!(collision.map(|tup|tup.1),expected_collision_time,"Incorrect time of collision");
|
||||||
|
}
|
||||||
|
#[allow(dead_code)]
|
||||||
|
fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
|
||||||
|
let h0=Hitbox::new(PhysicsMesh::from(&crate::primitives::unit_cube()),
|
||||||
|
integer::Planar64Affine3::new(
|
||||||
|
integer::Planar64Mat3::from_cols(
|
||||||
|
Planar64Vec3::int(5,0,1)/2,
|
||||||
|
Planar64Vec3::int(0,1,0)/2,
|
||||||
|
Planar64Vec3::int(-1,0,5)/2,
|
||||||
|
),
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
)
|
||||||
|
);
|
||||||
|
let h1=Hitbox::roblox();
|
||||||
|
let hitbox_mesh=h1.transformed_mesh();
|
||||||
|
let platform_mesh=h0.transformed_mesh();
|
||||||
|
let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&platform_mesh,&hitbox_mesh);
|
||||||
|
let collision=minkowski.predict_collision_in(&relative_body,Time::MAX);
|
||||||
|
assert_eq!(collision.map(|tup|tup.1),expected_collision_time,"Incorrect time of collision");
|
||||||
|
}
|
||||||
|
#[allow(dead_code)]
|
||||||
|
fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
|
||||||
|
test_collision_axis_aligned(relative_body.clone(),expected_collision_time);
|
||||||
|
test_collision_rotated(relative_body,expected_collision_time);
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_degenerate(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(0,5,0),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Time::ZERO
|
||||||
|
),Some(Time::from_secs(2)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_degenerate_east(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(3,5,0),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Time::ZERO
|
||||||
|
),Some(Time::from_secs(2)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_degenerate_south(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(0,5,3),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Time::ZERO
|
||||||
|
),Some(Time::from_secs(2)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_degenerate_west(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(-3,5,0),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Time::ZERO
|
||||||
|
),Some(Time::from_secs(2)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_degenerate_north(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(0,5,-3),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Time::ZERO
|
||||||
|
),Some(Time::from_secs(2)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_east_from_west(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(3,3,0),
|
||||||
|
Planar64Vec3::int(100,-1,0),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_south_from_north(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(0,3,3),
|
||||||
|
Planar64Vec3::int(0,-1,100),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_west_from_east(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(-3,3,0),
|
||||||
|
Planar64Vec3::int(-100,-1,0),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_north_from_south(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(0,3,-3),
|
||||||
|
Planar64Vec3::int(0,-1,-100),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_north_from_ne(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(0,6,-7)/2,
|
||||||
|
Planar64Vec3::int(-10,-1,1),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_north_from_nw(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(0,6,-7)/2,
|
||||||
|
Planar64Vec3::int(10,-1,1),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_east_from_se(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(7,6,0)/2,
|
||||||
|
Planar64Vec3::int(-1,-1,-10),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_east_from_ne(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(7,6,0)/2,
|
||||||
|
Planar64Vec3::int(-1,-1,10),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_south_from_se(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(0,6,7)/2,
|
||||||
|
Planar64Vec3::int(-10,-1,-1),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_south_from_sw(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(0,6,7)/2,
|
||||||
|
Planar64Vec3::int(10,-1,-1),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_west_from_se(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(-7,6,0)/2,
|
||||||
|
Planar64Vec3::int(1,-1,-10),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_parabola_edge_west_from_ne(){
|
||||||
|
test_collision(VirtualBody::relative(&Body::default(),&Body::new(
|
||||||
|
Planar64Vec3::int(-7,6,0)/2,
|
||||||
|
Planar64Vec3::int(1,-1,10),
|
||||||
|
Planar64Vec3::int(0,-1,0),
|
||||||
|
Time::ZERO
|
||||||
|
)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn test_collision_oblique(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(0,5,0),
|
||||||
|
Planar64Vec3::int(1,-64,2)/64,
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Time::ZERO
|
||||||
|
),Some(Time::from_secs(2)));
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn zoom_hit_nothing(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::int(0,10,0),
|
||||||
|
Planar64Vec3::int(1,0,0),
|
||||||
|
Planar64Vec3::int(0,1,0),
|
||||||
|
Time::ZERO
|
||||||
|
),None);
|
||||||
|
}
|
||||||
|
#[test]
|
||||||
|
fn already_inside_hit_nothing(){
|
||||||
|
test_collision(Body::new(
|
||||||
|
Planar64Vec3::ZERO,
|
||||||
|
Planar64Vec3::int(1,0,0),
|
||||||
|
Planar64Vec3::int(0,1,0),
|
||||||
|
Time::ZERO
|
||||||
|
),None);
|
||||||
|
}
|
@ -1,6 +1,8 @@
|
|||||||
use crate::integer::Time;
|
|
||||||
use crate::physics::{MouseState,PhysicsInputInstruction};
|
use crate::physics::{MouseState,PhysicsInputInstruction};
|
||||||
use crate::instruction::{TimedInstruction,InstructionConsumer};
|
use strafesnet_common::integer::Time;
|
||||||
|
use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
|
||||||
|
use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum InputInstruction {
|
pub enum InputInstruction {
|
||||||
MoveMouse(glam::IVec2),
|
MoveMouse(glam::IVec2),
|
||||||
@ -23,10 +25,35 @@ pub enum Instruction{
|
|||||||
//Graphics(crate::graphics_worker::Instruction),
|
//Graphics(crate::graphics_worker::Instruction),
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub struct Speed{
|
||||||
|
pub player_vel:Planar64Vec3,
|
||||||
|
pub time:Time
|
||||||
|
}
|
||||||
|
|
||||||
|
impl std::ops::Neg for Speed{
|
||||||
|
type Output=Self;
|
||||||
|
fn neg(self)->Self::Output{
|
||||||
|
Self{
|
||||||
|
player_vel:self.player_vel,
|
||||||
|
time:self.time
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Speed{
|
||||||
|
pub fn new(player_vel:Planar64Vec3,time:Time)->Self{
|
||||||
|
Self{
|
||||||
|
player_vel,
|
||||||
|
time,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
pub fn new(mut physics:crate::physics::PhysicsState,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
|
pub fn new(mut physics:crate::physics::PhysicsState,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
|
||||||
let mut mouse_blocking=true;
|
let mut mouse_blocking=true;
|
||||||
let mut last_mouse_time=physics.next_mouse.time;
|
let mut last_mouse_time=physics.next_mouse.time;
|
||||||
let mut timeline=std::collections::VecDeque::new();
|
let mut timeline=std::collections::VecDeque::new();
|
||||||
|
let mut next_velocity_print=std::time::Instant::now();
|
||||||
|
let mut player_vel = physics.body.velocity.length();
|
||||||
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
|
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
|
||||||
if if let Some(phys_input)=match &ins.instruction{
|
if if let Some(phys_input)=match &ins.instruction{
|
||||||
Instruction::Input(input_instruction)=>match input_instruction{
|
Instruction::Input(input_instruction)=>match input_instruction{
|
||||||
@ -110,6 +137,11 @@ pub enum Instruction{
|
|||||||
instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
|
instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
//some random print stuff
|
||||||
|
if 3.0/5.0<next_velocity_print.elapsed().as_secs_f64(){
|
||||||
|
next_velocity_print=next_velocity_print+std::time::Duration::from_secs_f64(1.0/30.0);
|
||||||
|
println!("velocity: {} u/s", (Planar64Vec3::new(physics.body.velocity.x(), Planar64::int(0), physics.body.velocity.z())).length()*(Planar64::int(130)/9));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
match ins.instruction{
|
match ins.instruction{
|
||||||
Instruction::Render=>{
|
Instruction::Render=>{
|
||||||
|
@ -1,5 +1,5 @@
|
|||||||
use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
|
use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
|
||||||
use crate::integer::Planar64Vec3;
|
use strafesnet_common::integer::Planar64Vec3;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum Primitives{
|
pub enum Primitives{
|
||||||
|
@ -1,4 +1,4 @@
|
|||||||
use crate::integer::{Ratio64,Ratio64Vec2};
|
use strafesnet_common::integer::{Ratio64,Ratio64Vec2};
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
struct Ratio{
|
struct Ratio{
|
||||||
ratio:f64,
|
ratio:f64,
|
||||||
|
88
src/setup.rs
88
src/setup.rs
@ -1,5 +1,6 @@
|
|||||||
use crate::instruction::TimedInstruction;
|
|
||||||
use crate::window::WindowInstruction;
|
use crate::window::WindowInstruction;
|
||||||
|
use strafesnet_common::instruction::TimedInstruction;
|
||||||
|
use strafesnet_common::integer;
|
||||||
|
|
||||||
fn optional_features()->wgpu::Features{
|
fn optional_features()->wgpu::Features{
|
||||||
wgpu::Features::TEXTURE_COMPRESSION_ASTC
|
wgpu::Features::TEXTURE_COMPRESSION_ASTC
|
||||||
@ -46,21 +47,21 @@ fn create_instance()->SetupContextPartial1{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl SetupContextPartial1{
|
impl SetupContextPartial1{
|
||||||
fn create_surface(self,window:&winit::window::Window)->Result<SetupContextPartial2,wgpu::CreateSurfaceError>{
|
fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
|
||||||
Ok(SetupContextPartial2{
|
Ok(SetupContextPartial2{
|
||||||
backends:self.backends,
|
backends:self.backends,
|
||||||
surface:unsafe{self.instance.create_surface(window)}?,
|
surface:self.instance.create_surface(window)?,
|
||||||
instance:self.instance,
|
instance:self.instance,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
struct SetupContextPartial2{
|
struct SetupContextPartial2<'a>{
|
||||||
backends:wgpu::Backends,
|
backends:wgpu::Backends,
|
||||||
instance:wgpu::Instance,
|
instance:wgpu::Instance,
|
||||||
surface:wgpu::Surface,
|
surface:wgpu::Surface<'a>,
|
||||||
}
|
}
|
||||||
impl SetupContextPartial2{
|
impl<'a> SetupContextPartial2<'a>{
|
||||||
fn pick_adapter(self)->SetupContextPartial3{
|
fn pick_adapter(self)->SetupContextPartial3<'a>{
|
||||||
let adapter;
|
let adapter;
|
||||||
|
|
||||||
//TODO: prefer adapter that implements optional features
|
//TODO: prefer adapter that implements optional features
|
||||||
@ -122,13 +123,13 @@ impl SetupContextPartial2{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
struct SetupContextPartial3{
|
struct SetupContextPartial3<'a>{
|
||||||
instance:wgpu::Instance,
|
instance:wgpu::Instance,
|
||||||
surface:wgpu::Surface,
|
surface:wgpu::Surface<'a>,
|
||||||
adapter:wgpu::Adapter,
|
adapter:wgpu::Adapter,
|
||||||
}
|
}
|
||||||
impl SetupContextPartial3{
|
impl<'a> SetupContextPartial3<'a>{
|
||||||
fn request_device(self)->SetupContextPartial4{
|
fn request_device(self)->SetupContextPartial4<'a>{
|
||||||
let optional_features=optional_features();
|
let optional_features=optional_features();
|
||||||
let required_features=required_features();
|
let required_features=required_features();
|
||||||
|
|
||||||
@ -140,8 +141,8 @@ impl SetupContextPartial3{
|
|||||||
.request_device(
|
.request_device(
|
||||||
&wgpu::DeviceDescriptor {
|
&wgpu::DeviceDescriptor {
|
||||||
label: None,
|
label: None,
|
||||||
features: (optional_features & self.adapter.features()) | required_features,
|
required_features: (optional_features & self.adapter.features()) | required_features,
|
||||||
limits: needed_limits,
|
required_limits: needed_limits,
|
||||||
},
|
},
|
||||||
trace_dir.ok().as_ref().map(std::path::Path::new),
|
trace_dir.ok().as_ref().map(std::path::Path::new),
|
||||||
))
|
))
|
||||||
@ -156,15 +157,15 @@ impl SetupContextPartial3{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
struct SetupContextPartial4{
|
struct SetupContextPartial4<'a>{
|
||||||
instance:wgpu::Instance,
|
instance:wgpu::Instance,
|
||||||
surface:wgpu::Surface,
|
surface:wgpu::Surface<'a>,
|
||||||
adapter:wgpu::Adapter,
|
adapter:wgpu::Adapter,
|
||||||
device:wgpu::Device,
|
device:wgpu::Device,
|
||||||
queue:wgpu::Queue,
|
queue:wgpu::Queue,
|
||||||
}
|
}
|
||||||
impl SetupContextPartial4{
|
impl<'a> SetupContextPartial4<'a>{
|
||||||
fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->SetupContext{
|
fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
|
||||||
let mut config=self.surface
|
let mut config=self.surface
|
||||||
.get_default_config(&self.adapter, size.width, size.height)
|
.get_default_config(&self.adapter, size.width, size.height)
|
||||||
.expect("Surface isn't supported by the adapter.");
|
.expect("Surface isn't supported by the adapter.");
|
||||||
@ -182,65 +183,42 @@ impl SetupContextPartial4{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub struct SetupContext{
|
pub struct SetupContext<'a>{
|
||||||
pub instance:wgpu::Instance,
|
pub instance:wgpu::Instance,
|
||||||
pub surface:wgpu::Surface,
|
pub surface:wgpu::Surface<'a>,
|
||||||
pub device:wgpu::Device,
|
pub device:wgpu::Device,
|
||||||
pub queue:wgpu::Queue,
|
pub queue:wgpu::Queue,
|
||||||
pub config:wgpu::SurfaceConfiguration,
|
pub config:wgpu::SurfaceConfiguration,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn setup(title:&str)->SetupContextSetup{
|
pub fn setup_and_start(title:String){
|
||||||
let event_loop=winit::event_loop::EventLoop::new().unwrap();
|
let event_loop=winit::event_loop::EventLoop::new().unwrap();
|
||||||
|
|
||||||
let window=create_window(title,&event_loop).unwrap();
|
|
||||||
|
|
||||||
println!("Initializing the surface...");
|
println!("Initializing the surface...");
|
||||||
|
|
||||||
let partial_1=create_instance();
|
let partial_1=create_instance();
|
||||||
|
|
||||||
|
let window=create_window(title.as_str(),&event_loop).unwrap();
|
||||||
|
|
||||||
let partial_2=partial_1.create_surface(&window).unwrap();
|
let partial_2=partial_1.create_surface(&window).unwrap();
|
||||||
|
|
||||||
let partial_3=partial_2.pick_adapter();
|
let partial_3=partial_2.pick_adapter();
|
||||||
|
|
||||||
let partial_4=partial_3.request_device();
|
let partial_4=partial_3.request_device();
|
||||||
|
|
||||||
SetupContextSetup{
|
let size=window.inner_size();
|
||||||
window,
|
|
||||||
event_loop,
|
|
||||||
partial_context:partial_4,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct SetupContextSetup{
|
let setup_context=partial_4.configure_surface(&size);
|
||||||
window:winit::window::Window,
|
|
||||||
event_loop:winit::event_loop::EventLoop<()>,
|
|
||||||
partial_context:SetupContextPartial4,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl SetupContextSetup{
|
//dedicated thread to ping request redraw back and resize the window doesn't seem logical
|
||||||
fn into_split(self)->(winit::window::Window,winit::event_loop::EventLoop<()>,SetupContext){
|
|
||||||
let size=self.window.inner_size();
|
|
||||||
//Steal values and drop self
|
|
||||||
(
|
|
||||||
self.window,
|
|
||||||
self.event_loop,
|
|
||||||
self.partial_context.configure_surface(&size),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
pub fn start(self){
|
|
||||||
let (window,event_loop,setup_context)=self.into_split();
|
|
||||||
|
|
||||||
//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
|
||||||
|
let window_thread=window.into_worker(setup_context);
|
||||||
|
|
||||||
let window=crate::window::WindowContextSetup::new(&setup_context,window);
|
println!("Entering event loop...");
|
||||||
//the thread that spawns the physics thread
|
let root_time=std::time::Instant::now();
|
||||||
let window_thread=window.into_worker(setup_context);
|
run_event_loop(event_loop,window_thread,root_time).unwrap();
|
||||||
|
|
||||||
println!("Entering event loop...");
|
|
||||||
let root_time=std::time::Instant::now();
|
|
||||||
run_event_loop(event_loop,window_thread,root_time).unwrap();
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn run_event_loop(
|
fn run_event_loop(
|
||||||
@ -249,7 +227,7 @@ fn run_event_loop(
|
|||||||
root_time:std::time::Instant
|
root_time:std::time::Instant
|
||||||
)->Result<(),winit::error::EventLoopError>{
|
)->Result<(),winit::error::EventLoopError>{
|
||||||
event_loop.run(move |event,elwt|{
|
event_loop.run(move |event,elwt|{
|
||||||
let time=crate::integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
|
let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
|
||||||
// *control_flow=if cfg!(feature="metal-auto-capture"){
|
// *control_flow=if cfg!(feature="metal-auto-capture"){
|
||||||
// winit::event_loop::ControlFlow::Exit
|
// winit::event_loop::ControlFlow::Exit
|
||||||
// }else{
|
// }else{
|
||||||
|
@ -1,5 +1,6 @@
|
|||||||
use crate::instruction::TimedInstruction;
|
|
||||||
use crate::physics_worker::InputInstruction;
|
use crate::physics_worker::InputInstruction;
|
||||||
|
use strafesnet_common::integer;
|
||||||
|
use strafesnet_common::instruction::TimedInstruction;
|
||||||
|
|
||||||
pub enum WindowInstruction{
|
pub enum WindowInstruction{
|
||||||
Resize(winit::dpi::PhysicalSize<u32>),
|
Resize(winit::dpi::PhysicalSize<u32>),
|
||||||
@ -15,7 +16,7 @@ struct WindowContext<'a>{
|
|||||||
mouse:crate::physics::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,
|
user_settings:crate::settings::UserSettings,
|
||||||
window: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>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -23,7 +24,7 @@ impl WindowContext<'_>{
|
|||||||
fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
|
fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
|
||||||
winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0)
|
winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0)
|
||||||
}
|
}
|
||||||
fn window_event(&mut self,time:crate::integer::Time,event: winit::event::WindowEvent) {
|
fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) {
|
||||||
match event {
|
match event {
|
||||||
winit::event::WindowEvent::DroppedFile(path)=>{
|
winit::event::WindowEvent::DroppedFile(path)=>{
|
||||||
//blocking because it's simpler...
|
//blocking because it's simpler...
|
||||||
@ -121,7 +122,7 @@ impl WindowContext<'_>{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
|
fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
|
||||||
match event {
|
match event {
|
||||||
winit::event::DeviceEvent::MouseMotion {
|
winit::event::DeviceEvent::MouseMotion {
|
||||||
delta,//these (f64,f64) are integers on my machine
|
delta,//these (f64,f64) are integers on my machine
|
||||||
@ -158,15 +159,15 @@ impl WindowContext<'_>{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct WindowContextSetup{
|
pub struct WindowContextSetup<'a>{
|
||||||
user_settings:crate::settings::UserSettings,
|
user_settings:crate::settings::UserSettings,
|
||||||
window:winit::window::Window,
|
window:&'a winit::window::Window,
|
||||||
physics:crate::physics::PhysicsState,
|
physics:crate::physics::PhysicsState,
|
||||||
graphics:crate::graphics::GraphicsState,
|
graphics:crate::graphics::GraphicsState,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl WindowContextSetup{
|
impl<'a> WindowContextSetup<'a>{
|
||||||
pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
|
pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
|
||||||
//wee
|
//wee
|
||||||
let user_settings=crate::settings::read_user_settings();
|
let user_settings=crate::settings::read_user_settings();
|
||||||
|
|
||||||
@ -194,7 +195,7 @@ impl WindowContextSetup{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn into_context<'a>(self,setup_context:crate::setup::SetupContext)->WindowContext<'a>{
|
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(self.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);
|
||||||
WindowContext{
|
WindowContext{
|
||||||
@ -208,7 +209,7 @@ impl WindowContextSetup{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn into_worker<'a>(self,setup_context:crate::setup::SetupContext)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
|
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);
|
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{
|
||||||
|
@ -175,16 +175,16 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
|
|||||||
|
|
||||||
#[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() {
|
||||||
println!("hiiiii");
|
|
||||||
// Create the worker thread
|
// Create the worker thread
|
||||||
|
let test_body=crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO);
|
||||||
let worker=QRWorker::new(crate::physics::Body::default(),
|
let worker=QRWorker::new(crate::physics::Body::default(),
|
||||||
|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
|
|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
|
||||||
);
|
);
|
||||||
|
|
||||||
// Send tasks to the worker
|
// Send tasks to the worker
|
||||||
for _ in 0..5 {
|
for _ in 0..5 {
|
||||||
let task = crate::instruction::TimedInstruction{
|
let task = strafesnet_common::instruction::TimedInstruction{
|
||||||
time:crate::integer::Time::ZERO,
|
time:strafesnet_common::integer::Time::ZERO,
|
||||||
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
||||||
};
|
};
|
||||||
worker.send(task).unwrap();
|
worker.send(task).unwrap();
|
||||||
@ -197,13 +197,13 @@ fn test_worker() {
|
|||||||
thread::sleep(std::time::Duration::from_millis(10));
|
thread::sleep(std::time::Duration::from_millis(10));
|
||||||
|
|
||||||
// Send a new task
|
// Send a new task
|
||||||
let task = crate::instruction::TimedInstruction{
|
let task = strafesnet_common::instruction::TimedInstruction{
|
||||||
time:crate::integer::Time::ZERO,
|
time:strafesnet_common::integer::Time::ZERO,
|
||||||
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
||||||
};
|
};
|
||||||
worker.send(task).unwrap();
|
worker.send(task).unwrap();
|
||||||
|
|
||||||
println!("value={}",worker.grab_clone());
|
//assert_eq!(test_body,worker.grab_clone());
|
||||||
|
|
||||||
// wait long enough to see print from final task
|
// wait long enough to see print from final task
|
||||||
thread::sleep(std::time::Duration::from_millis(10));
|
thread::sleep(std::time::Duration::from_millis(10));
|
||||||
|
@ -1,34 +0,0 @@
|
|||||||
//find roots of polynomials
|
|
||||||
use crate::integer::Planar64;
|
|
||||||
|
|
||||||
#[inline]
|
|
||||||
pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
|
|
||||||
if a2==Planar64::ZERO{
|
|
||||||
return zeroes1(a0, a1);
|
|
||||||
}
|
|
||||||
let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
|
|
||||||
if 0<radicand {
|
|
||||||
//start with f64 sqrt
|
|
||||||
let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
|
|
||||||
//TODO: one or two newtons
|
|
||||||
//sort roots ascending and avoid taking the difference of large numbers
|
|
||||||
match (Planar64::ZERO<a2,Planar64::ZERO<a1){
|
|
||||||
(true, true )=>vec![(-a1-planar_radicand)/(a2*2),(a0*2)/(-a1-planar_radicand)],
|
|
||||||
(true, false)=>vec![(a0*2)/(-a1+planar_radicand),(-a1+planar_radicand)/(a2*2)],
|
|
||||||
(false,true )=>vec![(a0*2)/(-a1-planar_radicand),(-a1-planar_radicand)/(a2*2)],
|
|
||||||
(false,false)=>vec![(-a1+planar_radicand)/(a2*2),(a0*2)/(-a1+planar_radicand)],
|
|
||||||
}
|
|
||||||
} else if radicand==0 {
|
|
||||||
return vec![a1/(a2*-2)];
|
|
||||||
} else {
|
|
||||||
return vec![];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
pub fn zeroes1(a0:Planar64,a1:Planar64) -> Vec<Planar64> {
|
|
||||||
if a1==Planar64::ZERO{
|
|
||||||
return vec![];
|
|
||||||
} else {
|
|
||||||
return vec![-a0/a1];
|
|
||||||
}
|
|
||||||
}
|
|
Loading…
Reference in New Issue
Block a user