forked from StrafesNET/strafe-client
Compare commits
14 Commits
Author | SHA1 | Date | |
---|---|---|---|
54c0ef47c1 | |||
df2524cd2d | |||
d832004e03 | |||
f929a61ac4 | |||
aefaa8454c | |||
83e108c8e1 | |||
fde62febcf | |||
c5ecf6b34a | |||
2d2f0099ab | |||
edd15d0a09 | |||
526666651a | |||
9005de6e8e | |||
6114835471 | |||
cea51457a6 |
1708
Cargo.lock
generated
1708
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
14
Cargo.toml
14
Cargo.toml
@ -1,16 +1,19 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "strafe-client"
|
name = "strafe-client"
|
||||||
version = "0.9.0"
|
version = "0.8.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
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
|
async-executor = "1.5.1"
|
||||||
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.25.0"
|
env_logger = "0.10.0"
|
||||||
|
glam = "0.24.1"
|
||||||
lazy-regex = "3.0.2"
|
lazy-regex = "3.0.2"
|
||||||
|
log = "0.4.20"
|
||||||
obj = "0.10.2"
|
obj = "0.10.2"
|
||||||
parking_lot = "0.12.1"
|
parking_lot = "0.12.1"
|
||||||
pollster = "0.3.0"
|
pollster = "0.3.0"
|
||||||
@ -18,11 +21,8 @@ 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"
|
||||||
strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "434ca29aef7e3015c9ca1ed45de8fef42e33fdfb" }
|
wgpu = "0.17.0"
|
||||||
vbsp = "0.5.0"
|
winit = "0.28.6"
|
||||||
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-2024 Rhys Lloyd <krakow20@gmail.com>
|
* Copyright (C) 2023 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.
|
||||||
*
|
*
|
||||||
|
89
src/aabb.rs
Normal file
89
src/aabb.rs
Normal file
@ -0,0 +1,89 @@
|
|||||||
|
use crate::integer::Planar64Vec3;
|
||||||
|
|
||||||
|
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
||||||
|
pub enum AabbFace{
|
||||||
|
Right,//+X
|
||||||
|
Top,
|
||||||
|
Back,
|
||||||
|
Left,
|
||||||
|
Bottom,
|
||||||
|
Front,
|
||||||
|
}
|
||||||
|
#[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{
|
||||||
|
const VERTEX_DATA:[Planar64Vec3;8]=[
|
||||||
|
Planar64Vec3::int( 1,-1,-1),
|
||||||
|
Planar64Vec3::int( 1, 1,-1),
|
||||||
|
Planar64Vec3::int( 1, 1, 1),
|
||||||
|
Planar64Vec3::int( 1,-1, 1),
|
||||||
|
Planar64Vec3::int(-1,-1, 1),
|
||||||
|
Planar64Vec3::int(-1, 1, 1),
|
||||||
|
Planar64Vec3::int(-1, 1,-1),
|
||||||
|
Planar64Vec3::int(-1,-1,-1),
|
||||||
|
];
|
||||||
|
|
||||||
|
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 normal(face:AabbFace)->Planar64Vec3{
|
||||||
|
match face {
|
||||||
|
AabbFace::Right=>Planar64Vec3::int(1,0,0),
|
||||||
|
AabbFace::Top=>Planar64Vec3::int(0,1,0),
|
||||||
|
AabbFace::Back=>Planar64Vec3::int(0,0,1),
|
||||||
|
AabbFace::Left=>Planar64Vec3::int(-1,0,0),
|
||||||
|
AabbFace::Bottom=>Planar64Vec3::int(0,-1,0),
|
||||||
|
AabbFace::Front=>Planar64Vec3::int(0,0,-1),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn unit_vertices()->[Planar64Vec3;8] {
|
||||||
|
return Self::VERTEX_DATA;
|
||||||
|
}
|
||||||
|
// pub fn face(&self,face:AabbFace)->Aabb {
|
||||||
|
// let mut aabb=self.clone();
|
||||||
|
// //in this implementation face = worldspace aabb face
|
||||||
|
// match face {
|
||||||
|
// AabbFace::Right => aabb.min.x=aabb.max.x,
|
||||||
|
// AabbFace::Top => aabb.min.y=aabb.max.y,
|
||||||
|
// AabbFace::Back => aabb.min.z=aabb.max.z,
|
||||||
|
// AabbFace::Left => aabb.max.x=aabb.min.x,
|
||||||
|
// AabbFace::Bottom => aabb.max.y=aabb.min.y,
|
||||||
|
// AabbFace::Front => aabb.max.z=aabb.min.z,
|
||||||
|
// }
|
||||||
|
// return aabb;
|
||||||
|
// }
|
||||||
|
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
|
||||||
|
// }
|
||||||
|
}
|
107
src/bvh.rs
Normal file
107
src/bvh.rs
Normal file
@ -0,0 +1,107 @@
|
|||||||
|
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
|
||||||
|
#[derive(Default)]
|
||||||
|
pub struct BvhNode{
|
||||||
|
children:Vec<Self>,
|
||||||
|
models:Vec<usize>,
|
||||||
|
aabb:Aabb,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BvhNode{
|
||||||
|
pub fn the_tester<F:FnMut(usize)>(&self,aabb:&Aabb,f:&mut F){
|
||||||
|
for &model in &self.models{
|
||||||
|
f(model);
|
||||||
|
}
|
||||||
|
for child in &self.children{
|
||||||
|
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 models=boxen.into_iter().map(|b|{aabb.join(&b.1);b.0}).collect();
|
||||||
|
BvhNode{
|
||||||
|
children:Vec::new(),
|
||||||
|
models,
|
||||||
|
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{
|
||||||
|
children,
|
||||||
|
models:Vec::new(),
|
||||||
|
aabb,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
@ -1,21 +0,0 @@
|
|||||||
pub type QNWorker<'a,Task>=CompatNWorker<'a,Task>;
|
|
||||||
pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
|
|
||||||
|
|
||||||
pub struct CompatNWorker<'a,Task>{
|
|
||||||
data:std::marker::PhantomData<Task>,
|
|
||||||
f:Box<dyn FnMut(Task)+Send+'a>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a,Task> CompatNWorker<'a,Task>{
|
|
||||||
pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
|
|
||||||
Self{
|
|
||||||
data:std::marker::PhantomData,
|
|
||||||
f:Box::new(f),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn send(&mut self,task:Task)->Result<(),()>{
|
|
||||||
(self.f)(task);
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
@ -1,119 +0,0 @@
|
|||||||
use crate::physics::Body;
|
|
||||||
use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
|
|
||||||
use strafesnet_common::integer::{Time,Planar64};
|
|
||||||
use strafesnet_common::zeroes::zeroes2;
|
|
||||||
|
|
||||||
enum Transition<F,E:DirectedEdge,V>{
|
|
||||||
Miss,
|
|
||||||
Next(FEV<F,E,V>,Time),
|
|
||||||
Hit(F,Time),
|
|
||||||
}
|
|
||||||
|
|
||||||
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>{
|
|
||||||
//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.
|
|
||||||
let mut best_time=time_limit;
|
|
||||||
let mut best_transtition=Transition::Miss;
|
|
||||||
match fev{
|
|
||||||
&FEV::<F,E,V>::Face(face_id)=>{
|
|
||||||
//test own face collision time, ignoring roots with zero or conflicting derivative
|
|
||||||
//n=face.normal d=face.dot
|
|
||||||
//n.a t^2+n.v t+n.p-d==0
|
|
||||||
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)){
|
|
||||||
let t=body.time+Time::from(t);
|
|
||||||
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
|
||||||
best_time=t;
|
|
||||||
best_transtition=Transition::Hit(face_id,t);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//test each edge collision time, ignoring roots with zero or conflicting derivative
|
|
||||||
for &directed_edge_id in mesh.face_edges(face_id).iter(){
|
|
||||||
let edge_n=mesh.directed_edge_n(directed_edge_id);
|
|
||||||
let n=n.cross(edge_n);
|
|
||||||
let verts=mesh.edge_verts(directed_edge_id.as_undirected());
|
|
||||||
//WARNING: d is moved out of the *2 block because of adding two vertices!
|
|
||||||
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);
|
|
||||||
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
|
||||||
best_time=t;
|
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//if none:
|
|
||||||
},
|
|
||||||
&FEV::<F,E,V>::Edge(edge_id)=>{
|
|
||||||
//test each face collision time, ignoring roots with zero or conflicting derivative
|
|
||||||
let edge_n=mesh.edge_n(edge_id);
|
|
||||||
let edge_verts=mesh.edge_verts(edge_id);
|
|
||||||
let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
|
|
||||||
for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
|
|
||||||
let face_n=mesh.face_nd(edge_face_id).0;
|
|
||||||
//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);
|
|
||||||
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
|
||||||
best_time=t;
|
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//test each vertex collision time, ignoring roots with zero or conflicting derivative
|
|
||||||
for (i,&vert_id) in edge_verts.iter().enumerate(){
|
|
||||||
//vertex normal gets parity from vert index
|
|
||||||
let n=edge_n*(1-2*(i as i64));
|
|
||||||
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);
|
|
||||||
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
|
||||||
best_time=t;
|
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//if none:
|
|
||||||
},
|
|
||||||
&FEV::<F,E,V>::Vert(vert_id)=>{
|
|
||||||
//test each edge collision time, ignoring roots with zero or conflicting derivative
|
|
||||||
for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
|
|
||||||
//edge is directed away from vertex, but we want the dot product to turn out negative
|
|
||||||
let n=-mesh.directed_edge_n(directed_edge_id);
|
|
||||||
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);
|
|
||||||
if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
|
|
||||||
best_time=t;
|
|
||||||
best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//if none:
|
|
||||||
},
|
|
||||||
}
|
|
||||||
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>{
|
|
||||||
let mut time=start_time;
|
|
||||||
for _ in 0..20{
|
|
||||||
match next_transition(&fev,time,mesh,relative_body,time_limit){
|
|
||||||
Transition::Miss=>return CrawlResult::Miss(fev),
|
|
||||||
Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
|
|
||||||
Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//TODO: fix all bugs
|
|
||||||
println!("Too many iterations! Using default behaviour instead of crashing...");
|
|
||||||
CrawlResult::Miss(fev)
|
|
||||||
}
|
|
516
src/framework.rs
Normal file
516
src/framework.rs
Normal file
@ -0,0 +1,516 @@
|
|||||||
|
use std::future::Future;
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
use std::str::FromStr;
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
|
||||||
|
use winit::{
|
||||||
|
event::{self, WindowEvent, DeviceEvent},
|
||||||
|
event_loop::{ControlFlow, EventLoop},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub fn cast_slice<T>(data: &[T]) -> &[u8] {
|
||||||
|
use std::{mem::size_of, slice::from_raw_parts};
|
||||||
|
|
||||||
|
unsafe { from_raw_parts(data.as_ptr() as *const u8, data.len() * size_of::<T>()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub enum ShaderStage {
|
||||||
|
Vertex,
|
||||||
|
Fragment,
|
||||||
|
Compute,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub trait Example: 'static + Sized {
|
||||||
|
fn optional_features() -> wgpu::Features {
|
||||||
|
wgpu::Features::empty()
|
||||||
|
}
|
||||||
|
fn required_features() -> wgpu::Features {
|
||||||
|
wgpu::Features::empty()
|
||||||
|
}
|
||||||
|
fn required_downlevel_capabilities() -> wgpu::DownlevelCapabilities {
|
||||||
|
wgpu::DownlevelCapabilities {
|
||||||
|
flags: wgpu::DownlevelFlags::empty(),
|
||||||
|
shader_model: wgpu::ShaderModel::Sm5,
|
||||||
|
..wgpu::DownlevelCapabilities::default()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn required_limits() -> wgpu::Limits {
|
||||||
|
wgpu::Limits::downlevel_webgl2_defaults() // These downlevel limits will allow the code to run on all possible hardware
|
||||||
|
}
|
||||||
|
fn init(
|
||||||
|
config: &wgpu::SurfaceConfiguration,
|
||||||
|
adapter: &wgpu::Adapter,
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
) -> Self;
|
||||||
|
fn resize(
|
||||||
|
&mut self,
|
||||||
|
config: &wgpu::SurfaceConfiguration,
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
);
|
||||||
|
fn update(&mut self, window: &winit::window::Window, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent);
|
||||||
|
fn device_event(&mut self, window: &winit::window::Window, event: DeviceEvent);
|
||||||
|
fn load_file(&mut self, path:std::path::PathBuf, device: &wgpu::Device, queue: &wgpu::Queue);
|
||||||
|
fn render(
|
||||||
|
&mut self,
|
||||||
|
view: &wgpu::TextureView,
|
||||||
|
device: &wgpu::Device,
|
||||||
|
queue: &wgpu::Queue,
|
||||||
|
spawner: &Spawner,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Setup {
|
||||||
|
window: winit::window::Window,
|
||||||
|
event_loop: EventLoop<()>,
|
||||||
|
instance: wgpu::Instance,
|
||||||
|
size: winit::dpi::PhysicalSize<u32>,
|
||||||
|
surface: wgpu::Surface,
|
||||||
|
adapter: wgpu::Adapter,
|
||||||
|
device: wgpu::Device,
|
||||||
|
queue: wgpu::Queue,
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
offscreen_canvas_setup: Option<OffscreenCanvasSetup>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
struct OffscreenCanvasSetup {
|
||||||
|
offscreen_canvas: OffscreenCanvas,
|
||||||
|
bitmap_renderer: ImageBitmapRenderingContext,
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn setup<E: Example>(title: &str) -> Setup {
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
{
|
||||||
|
env_logger::init();
|
||||||
|
};
|
||||||
|
|
||||||
|
let event_loop = EventLoop::new();
|
||||||
|
let mut builder = winit::window::WindowBuilder::new();
|
||||||
|
builder = builder.with_title(title);
|
||||||
|
#[cfg(windows_OFF)] // TODO
|
||||||
|
{
|
||||||
|
use winit::platform::windows::WindowBuilderExtWindows;
|
||||||
|
builder = builder.with_no_redirection_bitmap(true);
|
||||||
|
}
|
||||||
|
let window = builder.build(&event_loop).unwrap();
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
{
|
||||||
|
use winit::platform::web::WindowExtWebSys;
|
||||||
|
let query_string = web_sys::window().unwrap().location().search().unwrap();
|
||||||
|
let level: log::Level = parse_url_query_string(&query_string, "RUST_LOG")
|
||||||
|
.and_then(|x| x.parse().ok())
|
||||||
|
.unwrap_or(log::Level::Error);
|
||||||
|
console_log::init_with_level(level).expect("could not initialize logger");
|
||||||
|
std::panic::set_hook(Box::new(console_error_panic_hook::hook));
|
||||||
|
// On wasm, append the canvas to the document body
|
||||||
|
web_sys::window()
|
||||||
|
.and_then(|win| win.document())
|
||||||
|
.and_then(|doc| doc.body())
|
||||||
|
.and_then(|body| {
|
||||||
|
body.append_child(&web_sys::Element::from(window.canvas()))
|
||||||
|
.ok()
|
||||||
|
})
|
||||||
|
.expect("couldn't append canvas to document body");
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
let mut offscreen_canvas_setup: Option<OffscreenCanvasSetup> = None;
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
{
|
||||||
|
use wasm_bindgen::JsCast;
|
||||||
|
use winit::platform::web::WindowExtWebSys;
|
||||||
|
|
||||||
|
let query_string = web_sys::window().unwrap().location().search().unwrap();
|
||||||
|
if let Some(offscreen_canvas_param) =
|
||||||
|
parse_url_query_string(&query_string, "offscreen_canvas")
|
||||||
|
{
|
||||||
|
if FromStr::from_str(offscreen_canvas_param) == Ok(true) {
|
||||||
|
log::info!("Creating OffscreenCanvasSetup");
|
||||||
|
|
||||||
|
let offscreen_canvas =
|
||||||
|
OffscreenCanvas::new(1024, 768).expect("couldn't create OffscreenCanvas");
|
||||||
|
|
||||||
|
let bitmap_renderer = window
|
||||||
|
.canvas()
|
||||||
|
.get_context("bitmaprenderer")
|
||||||
|
.expect("couldn't create ImageBitmapRenderingContext (Result)")
|
||||||
|
.expect("couldn't create ImageBitmapRenderingContext (Option)")
|
||||||
|
.dyn_into::<ImageBitmapRenderingContext>()
|
||||||
|
.expect("couldn't convert into ImageBitmapRenderingContext");
|
||||||
|
|
||||||
|
offscreen_canvas_setup = Some(OffscreenCanvasSetup {
|
||||||
|
offscreen_canvas,
|
||||||
|
bitmap_renderer,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
log::info!("Initializing the surface...");
|
||||||
|
|
||||||
|
let backends = wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
|
||||||
|
let dx12_shader_compiler = wgpu::util::dx12_shader_compiler_from_env().unwrap_or_default();
|
||||||
|
|
||||||
|
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
|
||||||
|
backends,
|
||||||
|
dx12_shader_compiler,
|
||||||
|
});
|
||||||
|
let (size, surface) = unsafe {
|
||||||
|
let size = window.inner_size();
|
||||||
|
|
||||||
|
#[cfg(any(not(target_arch = "wasm32"), target_os = "emscripten"))]
|
||||||
|
let surface = instance.create_surface(&window).unwrap();
|
||||||
|
#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
|
||||||
|
let surface = {
|
||||||
|
if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
|
||||||
|
log::info!("Creating surface from OffscreenCanvas");
|
||||||
|
instance.create_surface_from_offscreen_canvas(
|
||||||
|
offscreen_canvas_setup.offscreen_canvas.clone(),
|
||||||
|
)
|
||||||
|
} else {
|
||||||
|
instance.create_surface(&window)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
(size, surface)
|
||||||
|
};
|
||||||
|
|
||||||
|
let adapter;
|
||||||
|
|
||||||
|
let optional_features = E::optional_features();
|
||||||
|
let required_features = E::required_features();
|
||||||
|
|
||||||
|
//no helper function smh gotta write it myself
|
||||||
|
let adapters = instance.enumerate_adapters(backends);
|
||||||
|
|
||||||
|
let mut chosen_adapter = None;
|
||||||
|
let mut chosen_adapter_score=0;
|
||||||
|
for adapter in adapters {
|
||||||
|
if !adapter.is_surface_supported(&surface) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
let score=match adapter.get_info().device_type{
|
||||||
|
wgpu::DeviceType::IntegratedGpu=>3,
|
||||||
|
wgpu::DeviceType::DiscreteGpu=>4,
|
||||||
|
wgpu::DeviceType::VirtualGpu=>2,
|
||||||
|
wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
|
||||||
|
};
|
||||||
|
|
||||||
|
let adapter_features = adapter.features();
|
||||||
|
if chosen_adapter_score<score&&adapter_features.contains(required_features) {
|
||||||
|
chosen_adapter_score=score;
|
||||||
|
chosen_adapter=Some(adapter);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if let Some(maybe_chosen_adapter) = chosen_adapter{
|
||||||
|
adapter=maybe_chosen_adapter;
|
||||||
|
}else{
|
||||||
|
panic!("No suitable GPU adapters found on the system!");
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
{
|
||||||
|
let adapter_info = adapter.get_info();
|
||||||
|
println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
|
||||||
|
}
|
||||||
|
|
||||||
|
let required_downlevel_capabilities = E::required_downlevel_capabilities();
|
||||||
|
let downlevel_capabilities = adapter.get_downlevel_capabilities();
|
||||||
|
assert!(
|
||||||
|
downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
|
||||||
|
"Adapter does not support the minimum shader model required to run this example: {:?}",
|
||||||
|
required_downlevel_capabilities.shader_model
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
downlevel_capabilities
|
||||||
|
.flags
|
||||||
|
.contains(required_downlevel_capabilities.flags),
|
||||||
|
"Adapter does not support the downlevel capabilities required to run this example: {:?}",
|
||||||
|
required_downlevel_capabilities.flags - downlevel_capabilities.flags
|
||||||
|
);
|
||||||
|
|
||||||
|
// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
|
||||||
|
let needed_limits = E::required_limits().using_resolution(adapter.limits());
|
||||||
|
|
||||||
|
let trace_dir = std::env::var("WGPU_TRACE");
|
||||||
|
let (device, queue) = adapter
|
||||||
|
.request_device(
|
||||||
|
&wgpu::DeviceDescriptor {
|
||||||
|
label: None,
|
||||||
|
features: (optional_features & adapter.features()) | required_features,
|
||||||
|
limits: needed_limits,
|
||||||
|
},
|
||||||
|
trace_dir.ok().as_ref().map(std::path::Path::new),
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.expect("Unable to find a suitable GPU adapter!");
|
||||||
|
|
||||||
|
Setup {
|
||||||
|
window,
|
||||||
|
event_loop,
|
||||||
|
instance,
|
||||||
|
size,
|
||||||
|
surface,
|
||||||
|
adapter,
|
||||||
|
device,
|
||||||
|
queue,
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
offscreen_canvas_setup,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn start<E: Example>(
|
||||||
|
#[cfg(not(target_arch = "wasm32"))] Setup {
|
||||||
|
window,
|
||||||
|
event_loop,
|
||||||
|
instance,
|
||||||
|
size,
|
||||||
|
surface,
|
||||||
|
adapter,
|
||||||
|
device,
|
||||||
|
queue,
|
||||||
|
}: Setup,
|
||||||
|
#[cfg(target_arch = "wasm32")] Setup {
|
||||||
|
window,
|
||||||
|
event_loop,
|
||||||
|
instance,
|
||||||
|
size,
|
||||||
|
surface,
|
||||||
|
adapter,
|
||||||
|
device,
|
||||||
|
queue,
|
||||||
|
offscreen_canvas_setup,
|
||||||
|
}: Setup,
|
||||||
|
) {
|
||||||
|
let spawner = Spawner::new();
|
||||||
|
let mut config = surface
|
||||||
|
.get_default_config(&adapter, size.width, size.height)
|
||||||
|
.expect("Surface isn't supported by the adapter.");
|
||||||
|
let surface_view_format = config.format.add_srgb_suffix();
|
||||||
|
config.view_formats.push(surface_view_format);
|
||||||
|
surface.configure(&device, &config);
|
||||||
|
|
||||||
|
log::info!("Initializing the example...");
|
||||||
|
let mut example = E::init(&config, &adapter, &device, &queue);
|
||||||
|
|
||||||
|
log::info!("Entering render loop...");
|
||||||
|
event_loop.run(move |event, _, control_flow| {
|
||||||
|
let _ = (&instance, &adapter); // force ownership by the closure
|
||||||
|
*control_flow = if cfg!(feature = "metal-auto-capture") {
|
||||||
|
ControlFlow::Exit
|
||||||
|
} else {
|
||||||
|
ControlFlow::Poll
|
||||||
|
};
|
||||||
|
match event {
|
||||||
|
event::Event::RedrawEventsCleared => {
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
spawner.run_until_stalled();
|
||||||
|
|
||||||
|
window.request_redraw();
|
||||||
|
}
|
||||||
|
event::Event::WindowEvent {
|
||||||
|
event:
|
||||||
|
WindowEvent::Resized(size)
|
||||||
|
| WindowEvent::ScaleFactorChanged {
|
||||||
|
new_inner_size: &mut size,
|
||||||
|
..
|
||||||
|
},
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
// Once winit is fixed, the detection conditions here can be removed.
|
||||||
|
// https://github.com/rust-windowing/winit/issues/2876
|
||||||
|
let max_dimension = adapter.limits().max_texture_dimension_2d;
|
||||||
|
if size.width > max_dimension || size.height > max_dimension {
|
||||||
|
log::warn!(
|
||||||
|
"The resizing size {:?} exceeds the limit of {}.",
|
||||||
|
size,
|
||||||
|
max_dimension
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
log::info!("Resizing to {:?}", size);
|
||||||
|
config.width = size.width.max(1);
|
||||||
|
config.height = size.height.max(1);
|
||||||
|
example.resize(&config, &device, &queue);
|
||||||
|
surface.configure(&device, &config);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
event::Event::WindowEvent { event, .. } => match event {
|
||||||
|
WindowEvent::KeyboardInput {
|
||||||
|
input:
|
||||||
|
event::KeyboardInput {
|
||||||
|
virtual_keycode: Some(event::VirtualKeyCode::Escape),
|
||||||
|
state: event::ElementState::Pressed,
|
||||||
|
..
|
||||||
|
},
|
||||||
|
..
|
||||||
|
}
|
||||||
|
| WindowEvent::CloseRequested => {
|
||||||
|
*control_flow = ControlFlow::Exit;
|
||||||
|
}
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
WindowEvent::KeyboardInput {
|
||||||
|
input:
|
||||||
|
event::KeyboardInput {
|
||||||
|
virtual_keycode: Some(event::VirtualKeyCode::Scroll),
|
||||||
|
state: event::ElementState::Pressed,
|
||||||
|
..
|
||||||
|
},
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
println!("{:#?}", instance.generate_report());
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
example.update(&window,&device,&queue,event);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
event::Event::DeviceEvent {
|
||||||
|
event,
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
example.device_event(&window,event);
|
||||||
|
},
|
||||||
|
event::Event::RedrawRequested(_) => {
|
||||||
|
|
||||||
|
let frame = match surface.get_current_texture() {
|
||||||
|
Ok(frame) => frame,
|
||||||
|
Err(_) => {
|
||||||
|
surface.configure(&device, &config);
|
||||||
|
surface
|
||||||
|
.get_current_texture()
|
||||||
|
.expect("Failed to acquire next surface texture!")
|
||||||
|
}
|
||||||
|
};
|
||||||
|
let view = frame.texture.create_view(&wgpu::TextureViewDescriptor {
|
||||||
|
format: Some(surface_view_format),
|
||||||
|
..wgpu::TextureViewDescriptor::default()
|
||||||
|
});
|
||||||
|
|
||||||
|
example.render(&view, &device, &queue, &spawner);
|
||||||
|
|
||||||
|
frame.present();
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
{
|
||||||
|
if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
|
||||||
|
let image_bitmap = offscreen_canvas_setup
|
||||||
|
.offscreen_canvas
|
||||||
|
.transfer_to_image_bitmap()
|
||||||
|
.expect("couldn't transfer offscreen canvas to image bitmap.");
|
||||||
|
offscreen_canvas_setup
|
||||||
|
.bitmap_renderer
|
||||||
|
.transfer_from_image_bitmap(&image_bitmap);
|
||||||
|
|
||||||
|
log::info!("Transferring OffscreenCanvas to ImageBitmapRenderer");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
pub struct Spawner<'a> {
|
||||||
|
executor: async_executor::LocalExecutor<'a>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
impl<'a> Spawner<'a> {
|
||||||
|
fn new() -> Self {
|
||||||
|
Self {
|
||||||
|
executor: async_executor::LocalExecutor::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub fn spawn_local(&self, future: impl Future<Output = ()> + 'a) {
|
||||||
|
self.executor.spawn(future).detach();
|
||||||
|
}
|
||||||
|
|
||||||
|
fn run_until_stalled(&self) {
|
||||||
|
while self.executor.try_tick() {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
pub struct Spawner {}
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
impl Spawner {
|
||||||
|
fn new() -> Self {
|
||||||
|
Self {}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub fn spawn_local(&self, future: impl Future<Output = ()> + 'static) {
|
||||||
|
wasm_bindgen_futures::spawn_local(future);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
|
pub fn run<E: Example>(title: &str) {
|
||||||
|
let setup = pollster::block_on(setup::<E>(title));
|
||||||
|
start::<E>(setup);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
pub fn run<E: Example>(title: &str) {
|
||||||
|
use wasm_bindgen::prelude::*;
|
||||||
|
|
||||||
|
let title = title.to_owned();
|
||||||
|
wasm_bindgen_futures::spawn_local(async move {
|
||||||
|
let setup = setup::<E>(&title).await;
|
||||||
|
let start_closure = Closure::once_into_js(move || start::<E>(setup));
|
||||||
|
|
||||||
|
// make sure to handle JS exceptions thrown inside start.
|
||||||
|
// Otherwise wasm_bindgen_futures Queue would break and never handle any tasks again.
|
||||||
|
// This is required, because winit uses JS exception for control flow to escape from `run`.
|
||||||
|
if let Err(error) = call_catch(&start_closure) {
|
||||||
|
let is_control_flow_exception = error.dyn_ref::<js_sys::Error>().map_or(false, |e| {
|
||||||
|
e.message().includes("Using exceptions for control flow", 0)
|
||||||
|
});
|
||||||
|
|
||||||
|
if !is_control_flow_exception {
|
||||||
|
web_sys::console::error_1(&error);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[wasm_bindgen]
|
||||||
|
extern "C" {
|
||||||
|
#[wasm_bindgen(catch, js_namespace = Function, js_name = "prototype.call.call")]
|
||||||
|
fn call_catch(this: &JsValue) -> Result<(), JsValue>;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
/// Parse the query string as returned by `web_sys::window()?.location().search()?` and get a
|
||||||
|
/// specific key out of it.
|
||||||
|
pub fn parse_url_query_string<'a>(query: &'a str, search_key: &str) -> Option<&'a str> {
|
||||||
|
let query_string = query.strip_prefix('?')?;
|
||||||
|
|
||||||
|
for pair in query_string.split('&') {
|
||||||
|
let mut pair = pair.split('=');
|
||||||
|
let key = pair.next()?;
|
||||||
|
let value = pair.next()?;
|
||||||
|
|
||||||
|
if key == search_key {
|
||||||
|
return Some(value);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
None
|
||||||
|
}
|
||||||
|
|
||||||
|
// This allows treating the framework as a standalone example,
|
||||||
|
// thus avoiding listing the example names in `Cargo.toml`.
|
||||||
|
#[allow(dead_code)]
|
||||||
|
fn main() {}
|
1013
src/graphics.rs
1013
src/graphics.rs
File diff suppressed because it is too large
Load Diff
@ -1,72 +0,0 @@
|
|||||||
use strafesnet_common::integer;
|
|
||||||
|
|
||||||
pub enum Instruction{
|
|
||||||
Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2),
|
|
||||||
//UpdateModel(crate::graphics::GraphicsModelUpdate),
|
|
||||||
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
|
|
||||||
GenerateModels(crate::model::IndexedModelInstances),
|
|
||||||
ClearModels,
|
|
||||||
}
|
|
||||||
|
|
||||||
//Ideally the graphics thread worker description is:
|
|
||||||
/*
|
|
||||||
WorkerDescription{
|
|
||||||
input:Immediate,
|
|
||||||
output:Realtime(PoolOrdering::Ordered(3)),
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
//up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
|
|
||||||
|
|
||||||
pub fn new<'a>(
|
|
||||||
mut graphics:crate::graphics::GraphicsState,
|
|
||||||
mut config:wgpu::SurfaceConfiguration,
|
|
||||||
surface:wgpu::Surface<'a>,
|
|
||||||
device:wgpu::Device,
|
|
||||||
queue:wgpu::Queue,
|
|
||||||
)->crate::compat_worker::INWorker<'a,Instruction>{
|
|
||||||
let mut resize=None;
|
|
||||||
crate::compat_worker::INWorker::new(move |ins:Instruction|{
|
|
||||||
match ins{
|
|
||||||
Instruction::GenerateModels(indexed_model_instances)=>{
|
|
||||||
graphics.generate_models(&device,&queue,indexed_model_instances);
|
|
||||||
},
|
|
||||||
Instruction::ClearModels=>{
|
|
||||||
graphics.clear();
|
|
||||||
},
|
|
||||||
Instruction::Resize(size,user_settings)=>{
|
|
||||||
resize=Some((size,user_settings));
|
|
||||||
}
|
|
||||||
Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
|
|
||||||
if let Some((size,user_settings))=&resize{
|
|
||||||
println!("Resizing to {:?}",size);
|
|
||||||
let t0=std::time::Instant::now();
|
|
||||||
config.width=size.width.max(1);
|
|
||||||
config.height=size.height.max(1);
|
|
||||||
surface.configure(&device,&config);
|
|
||||||
graphics.resize(&device,&config,user_settings);
|
|
||||||
println!("Resize took {:?}",t0.elapsed());
|
|
||||||
}
|
|
||||||
//clear every time w/e
|
|
||||||
resize=None;
|
|
||||||
//this has to go deeper somehow
|
|
||||||
let frame=match surface.get_current_texture(){
|
|
||||||
Ok(frame)=>frame,
|
|
||||||
Err(_)=>{
|
|
||||||
surface.configure(&device,&config);
|
|
||||||
surface
|
|
||||||
.get_current_texture()
|
|
||||||
.expect("Failed to acquire next surface texture!")
|
|
||||||
}
|
|
||||||
};
|
|
||||||
let view=frame.texture.create_view(&wgpu::TextureViewDescriptor{
|
|
||||||
format:Some(config.view_formats[0]),
|
|
||||||
..wgpu::TextureViewDescriptor::default()
|
|
||||||
});
|
|
||||||
|
|
||||||
graphics.render(&view,&device,&queue,physics_output,predicted_time,mouse_pos);
|
|
||||||
|
|
||||||
frame.present();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
50
src/instruction.rs
Normal file
50
src/instruction.rs
Normal file
@ -0,0 +1,50 @@
|
|||||||
|
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
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
953
src/integer.rs
Normal file
953
src/integer.rs
Normal file
@ -0,0 +1,953 @@
|
|||||||
|
//integer units
|
||||||
|
#[derive(Clone,Copy,Hash,PartialEq,PartialOrd,Debug)]
|
||||||
|
pub struct Time(i64);
|
||||||
|
impl Time{
|
||||||
|
pub const ZERO:Self=Self(0);
|
||||||
|
pub const ONE_SECOND:Self=Self(1_000_000_000);
|
||||||
|
pub const ONE_MILLISECOND:Self=Self(1_000_000);
|
||||||
|
pub const ONE_MICROSECOND:Self=Self(1_000);
|
||||||
|
pub const ONE_NANOSECOND:Self=Self(1);
|
||||||
|
#[inline]
|
||||||
|
pub fn from_secs(num:i64)->Self{
|
||||||
|
Self(Self::ONE_SECOND.0*num)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn from_millis(num:i64)->Self{
|
||||||
|
Self(Self::ONE_MILLISECOND.0*num)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn from_micros(num:i64)->Self{
|
||||||
|
Self(Self::ONE_MICROSECOND.0*num)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn from_nanos(num:i64)->Self{
|
||||||
|
Self(Self::ONE_NANOSECOND.0*num)
|
||||||
|
}
|
||||||
|
//should I have checked subtraction? force all time variables to be positive?
|
||||||
|
#[inline]
|
||||||
|
pub fn nanos(&self)->i64{
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<Planar64> for Time{
|
||||||
|
#[inline]
|
||||||
|
fn from(value:Planar64)->Self{
|
||||||
|
Time((((value.0 as i128)*1_000_000_000)>>32) as i64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::fmt::Display for Time{
|
||||||
|
#[inline]
|
||||||
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
|
write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Neg for Time{
|
||||||
|
type Output=Time;
|
||||||
|
#[inline]
|
||||||
|
fn neg(self)->Self::Output {
|
||||||
|
Time(-self.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Add<Time> for Time{
|
||||||
|
type Output=Time;
|
||||||
|
#[inline]
|
||||||
|
fn add(self,rhs:Self)->Self::Output {
|
||||||
|
Time(self.0+rhs.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Sub<Time> for Time{
|
||||||
|
type Output=Time;
|
||||||
|
#[inline]
|
||||||
|
fn sub(self,rhs:Self)->Self::Output {
|
||||||
|
Time(self.0-rhs.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Time> for Time{
|
||||||
|
type Output=Time;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:Time)->Self::Output{
|
||||||
|
Self((((self.0 as i128)*(rhs.0 as i128))/1_000_000_000) as i64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Div<i64> for Time{
|
||||||
|
type Output=Time;
|
||||||
|
#[inline]
|
||||||
|
fn div(self,rhs:i64)->Self::Output {
|
||||||
|
Time(self.0/rhs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
const fn gcd(mut a:u64,mut b:u64)->u64{
|
||||||
|
while b!=0{
|
||||||
|
(a,b)=(b,a.rem_euclid(b));
|
||||||
|
};
|
||||||
|
a
|
||||||
|
}
|
||||||
|
#[derive(Clone,Hash)]
|
||||||
|
pub struct Ratio64{
|
||||||
|
num:i64,
|
||||||
|
den:u64,
|
||||||
|
}
|
||||||
|
impl Ratio64{
|
||||||
|
pub const ZERO:Self=Ratio64{num:0,den:1};
|
||||||
|
pub const ONE:Self=Ratio64{num:1,den:1};
|
||||||
|
#[inline]
|
||||||
|
pub const fn new(num:i64,den:u64)->Option<Ratio64>{
|
||||||
|
if den==0{
|
||||||
|
None
|
||||||
|
}else{
|
||||||
|
let d=gcd(num.unsigned_abs(),den);
|
||||||
|
Some(Self{num:num/d as i64,den:den/d})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn mul_int(&self,rhs:i64)->i64{
|
||||||
|
rhs*self.num/self.den as i64
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn rhs_div_int(&self,rhs:i64)->i64{
|
||||||
|
rhs*self.den as i64/self.num
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn mul_ref(&self,rhs:&Ratio64)->Ratio64{
|
||||||
|
let (num,den)=(self.num*rhs.num,self.den*rhs.den);
|
||||||
|
let d=gcd(num.unsigned_abs(),den);
|
||||||
|
Self{
|
||||||
|
num:num/d as i64,
|
||||||
|
den:den/d,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//from num_traits crate
|
||||||
|
#[inline]
|
||||||
|
fn integer_decode_f32(f: f32) -> (u64, i16, i8) {
|
||||||
|
let bits: u32 = f.to_bits();
|
||||||
|
let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 };
|
||||||
|
let mut exponent: i16 = ((bits >> 23) & 0xff) as i16;
|
||||||
|
let mantissa = if exponent == 0 {
|
||||||
|
(bits & 0x7fffff) << 1
|
||||||
|
} else {
|
||||||
|
(bits & 0x7fffff) | 0x800000
|
||||||
|
};
|
||||||
|
// Exponent bias + mantissa shift
|
||||||
|
exponent -= 127 + 23;
|
||||||
|
(mantissa as u64, exponent, sign)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn integer_decode_f64(f: f64) -> (u64, i16, i8) {
|
||||||
|
let bits: u64 = f.to_bits();
|
||||||
|
let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 };
|
||||||
|
let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
|
||||||
|
let mantissa = if exponent == 0 {
|
||||||
|
(bits & 0xfffffffffffff) << 1
|
||||||
|
} else {
|
||||||
|
(bits & 0xfffffffffffff) | 0x10000000000000
|
||||||
|
};
|
||||||
|
// Exponent bias + mantissa shift
|
||||||
|
exponent -= 1023 + 52;
|
||||||
|
(mantissa, exponent, sign)
|
||||||
|
}
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Ratio64TryFromFloatError{
|
||||||
|
Nan,
|
||||||
|
Infinite,
|
||||||
|
Subnormal,
|
||||||
|
HighlyNegativeExponent(i16),
|
||||||
|
HighlyPositiveExponent(i16),
|
||||||
|
}
|
||||||
|
const MAX_DENOMINATOR:u128=u64::MAX as u128;
|
||||||
|
#[inline]
|
||||||
|
fn ratio64_from_mes((m,e,s):(u64,i16,i8))->Result<Ratio64,Ratio64TryFromFloatError>{
|
||||||
|
if e< -127{
|
||||||
|
//this can also just be zero
|
||||||
|
Err(Ratio64TryFromFloatError::HighlyNegativeExponent(e))
|
||||||
|
}else if e< -63{
|
||||||
|
//approximate input ratio within denominator limit
|
||||||
|
let mut target_num=m as u128;
|
||||||
|
let mut target_den=1u128<<-e;
|
||||||
|
|
||||||
|
let mut num=1;
|
||||||
|
let mut den=0;
|
||||||
|
let mut prev_num=0;
|
||||||
|
let mut prev_den=1;
|
||||||
|
|
||||||
|
while target_den!=0{
|
||||||
|
let whole=target_num/target_den;
|
||||||
|
(target_num,target_den)=(target_den,target_num-whole*target_den);
|
||||||
|
let new_num=whole*num+prev_num;
|
||||||
|
let new_den=whole*den+prev_den;
|
||||||
|
if MAX_DENOMINATOR<new_den{
|
||||||
|
break;
|
||||||
|
}else{
|
||||||
|
(prev_num,prev_den)=(num,den);
|
||||||
|
(num,den)=(new_num,new_den);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(Ratio64::new(num as i64,den as u64).unwrap())
|
||||||
|
}else if e<0{
|
||||||
|
Ok(Ratio64::new((m as i64)*(s as i64),1<<-e).unwrap())
|
||||||
|
}else if (64-m.leading_zeros() as i16)+e<64{
|
||||||
|
Ok(Ratio64::new((m as i64)*(s as i64)*(1<<e),1).unwrap())
|
||||||
|
}else{
|
||||||
|
Err(Ratio64TryFromFloatError::HighlyPositiveExponent(e))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<f32> for Ratio64{
|
||||||
|
type Error=Ratio64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:f32)->Result<Self,Self::Error>{
|
||||||
|
match value.classify(){
|
||||||
|
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
|
||||||
|
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
|
||||||
|
std::num::FpCategory::Zero=>Ok(Self::ZERO),
|
||||||
|
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
|
||||||
|
std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f32(value)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<f64> for Ratio64{
|
||||||
|
type Error=Ratio64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:f64)->Result<Self,Self::Error>{
|
||||||
|
match value.classify(){
|
||||||
|
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
|
||||||
|
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
|
||||||
|
std::num::FpCategory::Zero=>Ok(Self::ZERO),
|
||||||
|
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
|
||||||
|
std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f64(value)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Ratio64> for Ratio64{
|
||||||
|
type Output=Ratio64;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:Ratio64)->Self::Output{
|
||||||
|
let (num,den)=(self.num*rhs.num,self.den*rhs.den);
|
||||||
|
let d=gcd(num.unsigned_abs(),den);
|
||||||
|
Self{
|
||||||
|
num:num/d as i64,
|
||||||
|
den:den/d,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<i64> for Ratio64{
|
||||||
|
type Output=Ratio64;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:i64)->Self::Output {
|
||||||
|
Self{
|
||||||
|
num:self.num*rhs,
|
||||||
|
den:self.den,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Div<u64> for Ratio64{
|
||||||
|
type Output=Ratio64;
|
||||||
|
#[inline]
|
||||||
|
fn div(self,rhs:u64)->Self::Output {
|
||||||
|
Self{
|
||||||
|
num:self.num,
|
||||||
|
den:self.den*rhs,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[derive(Clone,Hash)]
|
||||||
|
pub struct Ratio64Vec2{
|
||||||
|
pub x:Ratio64,
|
||||||
|
pub y:Ratio64,
|
||||||
|
}
|
||||||
|
impl Ratio64Vec2{
|
||||||
|
pub const ONE:Self=Self{x:Ratio64::ONE,y:Ratio64::ONE};
|
||||||
|
#[inline]
|
||||||
|
pub fn new(x:Ratio64,y:Ratio64)->Self{
|
||||||
|
Self{x,y}
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn mul_int(&self,rhs:glam::I64Vec2)->glam::I64Vec2{
|
||||||
|
glam::i64vec2(
|
||||||
|
self.x.mul_int(rhs.x),
|
||||||
|
self.y.mul_int(rhs.y),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<i64> for Ratio64Vec2{
|
||||||
|
type Output=Ratio64Vec2;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:i64)->Self::Output {
|
||||||
|
Self{
|
||||||
|
x:self.x*rhs,
|
||||||
|
y:self.y*rhs,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
///[-pi,pi) = [-2^31,2^31-1]
|
||||||
|
#[derive(Clone,Copy,Hash)]
|
||||||
|
pub struct Angle32(i32);
|
||||||
|
impl Angle32{
|
||||||
|
pub const FRAC_PI_2:Self=Self(1<<30);
|
||||||
|
pub const PI:Self=Self(-1<<31);
|
||||||
|
#[inline]
|
||||||
|
pub fn wrap_from_i64(theta:i64)->Self{
|
||||||
|
//take lower bits
|
||||||
|
//note: this was checked on compiler explorer and compiles to 1 instruction!
|
||||||
|
Self(i32::from_ne_bytes(((theta&((1<<32)-1)) as u32).to_ne_bytes()))
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn clamp_from_i64(theta:i64)->Self{
|
||||||
|
//the assembly is a bit confusing for this, I thought it was checking the same thing twice
|
||||||
|
//but it's just checking and then overwriting the value for both upper and lower bounds.
|
||||||
|
Self(theta.clamp(i32::MIN as i64,i32::MAX as i64) as i32)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn get(&self)->i32{
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
/// Clamps the value towards the midpoint of the range.
|
||||||
|
/// Note that theta_min can be larger than theta_max and it will wrap clamp the other way around
|
||||||
|
#[inline]
|
||||||
|
pub fn clamp(&self,theta_min:Self,theta_max:Self)->Self{
|
||||||
|
//((max-min as u32)/2 as i32)+min
|
||||||
|
let midpoint=((
|
||||||
|
u32::from_ne_bytes(theta_max.0.to_ne_bytes())
|
||||||
|
.wrapping_sub(u32::from_ne_bytes(theta_min.0.to_ne_bytes()))
|
||||||
|
/2
|
||||||
|
) as i32)//(u32::MAX/2) as i32 ALWAYS works
|
||||||
|
.wrapping_add(theta_min.0);
|
||||||
|
//(theta-mid).clamp(max-mid,min-mid)+mid
|
||||||
|
Self(
|
||||||
|
self.0.wrapping_sub(midpoint)
|
||||||
|
.max(theta_min.0.wrapping_sub(midpoint))
|
||||||
|
.min(theta_max.0.wrapping_sub(midpoint))
|
||||||
|
.wrapping_add(midpoint)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
#[inline]
|
||||||
|
pub fn cos(&self)->Unit32{
|
||||||
|
//TODO: fix this rounding towards 0
|
||||||
|
Unit32(unsafe{((self.0 as f64*ANGLE32_TO_FLOAT64_RADIANS).cos()*UNIT32_ONE_FLOAT64).to_int_unchecked()})
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn sin(&self)->Unit32{
|
||||||
|
//TODO: fix this rounding towards 0
|
||||||
|
Unit32(unsafe{((self.0 as f64*ANGLE32_TO_FLOAT64_RADIANS).sin()*UNIT32_ONE_FLOAT64).to_int_unchecked()})
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
}
|
||||||
|
const ANGLE32_TO_FLOAT64_RADIANS:f64=std::f64::consts::PI/((1i64<<31) as f64);
|
||||||
|
impl Into<f32> for Angle32{
|
||||||
|
#[inline]
|
||||||
|
fn into(self)->f32{
|
||||||
|
(self.0 as f64*ANGLE32_TO_FLOAT64_RADIANS) as f32
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Neg for Angle32{
|
||||||
|
type Output=Angle32;
|
||||||
|
#[inline]
|
||||||
|
fn neg(self)->Self::Output{
|
||||||
|
Angle32(self.0.wrapping_neg())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Add<Angle32> for Angle32{
|
||||||
|
type Output=Angle32;
|
||||||
|
#[inline]
|
||||||
|
fn add(self,rhs:Self)->Self::Output {
|
||||||
|
Angle32(self.0.wrapping_add(rhs.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Sub<Angle32> for Angle32{
|
||||||
|
type Output=Angle32;
|
||||||
|
#[inline]
|
||||||
|
fn sub(self,rhs:Self)->Self::Output {
|
||||||
|
Angle32(self.0.wrapping_sub(rhs.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<i32> for Angle32{
|
||||||
|
type Output=Angle32;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:i32)->Self::Output {
|
||||||
|
Angle32(self.0.wrapping_mul(rhs))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Angle32> for Angle32{
|
||||||
|
type Output=Angle32;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:Self)->Self::Output {
|
||||||
|
Angle32(self.0.wrapping_mul(rhs.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Unit type unused for now, may revive it for map files
|
||||||
|
///[-1.0,1.0] = [-2^30,2^30]
|
||||||
|
pub struct Unit32(i32);
|
||||||
|
impl Unit32{
|
||||||
|
#[inline]
|
||||||
|
pub fn as_planar64(&self) -> Planar64{
|
||||||
|
Planar64(4*(self.0 as i64))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
const UNIT32_ONE_FLOAT64=((1<<30) as f64);
|
||||||
|
///[-1.0,1.0] = [-2^30,2^30]
|
||||||
|
pub struct Unit32Vec3(glam::IVec3);
|
||||||
|
impl TryFrom<[f32;3]> for Unit32Vec3{
|
||||||
|
type Error=Unit32TryFromFloatError;
|
||||||
|
fn try_from(value:[f32;3])->Result<Self,Self::Error>{
|
||||||
|
Ok(Self(glam::ivec3(
|
||||||
|
Unit32::try_from(Planar64::try_from(value[0])?)?.0,
|
||||||
|
Unit32::try_from(Planar64::try_from(value[1])?)?.0,
|
||||||
|
Unit32::try_from(Planar64::try_from(value[2])?)?.0,
|
||||||
|
)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
///[-1.0,1.0] = [-2^32,2^32]
|
||||||
|
#[derive(Clone,Copy,Hash,Eq,Ord,PartialEq,PartialOrd)]
|
||||||
|
pub struct Planar64(i64);
|
||||||
|
impl Planar64{
|
||||||
|
pub const ZERO:Self=Self(0);
|
||||||
|
pub const ONE:Self=Self(1<<32);
|
||||||
|
#[inline]
|
||||||
|
pub const fn int(num:i32)->Self{
|
||||||
|
Self(Self::ONE.0*num as i64)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub const fn raw(num:i64)->Self{
|
||||||
|
Self(num)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub const fn get(&self)->i64{
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
pub fn sqrt(&self)->Self{
|
||||||
|
Planar64(unsafe{(((self.0 as i128)<<32) as f64).sqrt().to_int_unchecked()})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
const PLANAR64_ONE_FLOAT32:f32=(1u64<<32) as f32;
|
||||||
|
const PLANAR64_CONVERT_TO_FLOAT32:f32=1.0/PLANAR64_ONE_FLOAT32;
|
||||||
|
const PLANAR64_ONE_FLOAT64:f64=(1u64<<32) as f64;
|
||||||
|
impl Into<f32> for Planar64{
|
||||||
|
#[inline]
|
||||||
|
fn into(self)->f32{
|
||||||
|
self.0 as f32*PLANAR64_CONVERT_TO_FLOAT32
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<Ratio64> for Planar64{
|
||||||
|
#[inline]
|
||||||
|
fn from(ratio:Ratio64)->Self{
|
||||||
|
Self((((ratio.num as i128)<<32)/ratio.den as i128) as i64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Planar64TryFromFloatError{
|
||||||
|
Nan,
|
||||||
|
Infinite,
|
||||||
|
Subnormal,
|
||||||
|
HighlyNegativeExponent(i16),
|
||||||
|
HighlyPositiveExponent(i16),
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn planar64_from_mes((m,e,s):(u64,i16,i8))->Result<Planar64,Planar64TryFromFloatError>{
|
||||||
|
let e32=e+32;
|
||||||
|
if e32<0&&(m>>-e32)==0{//shifting m will underflow to 0
|
||||||
|
Ok(Planar64::ZERO)
|
||||||
|
// println!("m{} e{} s{}",m,e,s);
|
||||||
|
// println!("f={}",(m as f64)*(2.0f64.powf(e as f64))*(s as f64));
|
||||||
|
// Err(Planar64TryFromFloatError::HighlyNegativeExponent(e))
|
||||||
|
}else if (64-m.leading_zeros() as i16)+e32<64{//shifting m will not overflow
|
||||||
|
if e32<0{
|
||||||
|
Ok(Planar64((m as i64)*(s as i64)>>-e32))
|
||||||
|
}else{
|
||||||
|
Ok(Planar64((m as i64)*(s as i64)<<e32))
|
||||||
|
}
|
||||||
|
}else{//if shifting m will overflow (prev check failed)
|
||||||
|
Err(Planar64TryFromFloatError::HighlyPositiveExponent(e))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<f32> for Planar64{
|
||||||
|
type Error=Planar64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:f32)->Result<Self,Self::Error>{
|
||||||
|
match value.classify(){
|
||||||
|
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
|
||||||
|
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
|
||||||
|
std::num::FpCategory::Zero=>Ok(Self::ZERO),
|
||||||
|
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
|
||||||
|
std::num::FpCategory::Normal=>planar64_from_mes(integer_decode_f32(value)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<f64> for Planar64{
|
||||||
|
type Error=Planar64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:f64)->Result<Self,Self::Error>{
|
||||||
|
match value.classify(){
|
||||||
|
std::num::FpCategory::Nan=>Err(Self::Error::Nan),
|
||||||
|
std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
|
||||||
|
std::num::FpCategory::Zero=>Ok(Self::ZERO),
|
||||||
|
std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
|
||||||
|
std::num::FpCategory::Normal=>planar64_from_mes(integer_decode_f64(value)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::fmt::Display for Planar64{
|
||||||
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
|
write!(f,"{:.3}",
|
||||||
|
Into::<f32>::into(*self),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Neg for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn neg(self)->Self::Output{
|
||||||
|
Planar64(-self.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Add<Planar64> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn add(self, rhs: Self) -> Self::Output {
|
||||||
|
Planar64(self.0+rhs.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Sub<Planar64> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn sub(self, rhs: Self) -> Self::Output {
|
||||||
|
Planar64(self.0-rhs.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<i64> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self, rhs: i64) -> Self::Output {
|
||||||
|
Planar64(self.0*rhs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Planar64> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self, rhs: Self) -> Self::Output {
|
||||||
|
Planar64(((self.0 as i128*rhs.0 as i128)>>32) as i64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Time> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:Time)->Self::Output{
|
||||||
|
Planar64(((self.0 as i128*rhs.0 as i128)/1_000_000_000) as i64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Div<i64> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn div(self, rhs: i64) -> Self::Output {
|
||||||
|
Planar64(self.0/rhs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Div<Planar64> for Planar64{
|
||||||
|
type Output=Planar64;
|
||||||
|
#[inline]
|
||||||
|
fn div(self, rhs: Planar64) -> Self::Output {
|
||||||
|
Planar64((((self.0 as i128)<<32)/rhs.0 as i128) as i64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// impl PartialOrd<i64> for Planar64{
|
||||||
|
// fn partial_cmp(&self, other: &i64) -> Option<std::cmp::Ordering> {
|
||||||
|
// self.0.partial_cmp(other)
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
|
||||||
|
|
||||||
|
///[-1.0,1.0] = [-2^32,2^32]
|
||||||
|
#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
|
||||||
|
pub struct Planar64Vec3(glam::I64Vec3);
|
||||||
|
impl Planar64Vec3{
|
||||||
|
pub const ZERO:Self=Planar64Vec3(glam::I64Vec3::ZERO);
|
||||||
|
pub const ONE:Self=Self::int(1,1,1);
|
||||||
|
pub const X:Self=Self::int(1,0,0);
|
||||||
|
pub const Y:Self=Self::int(0,1,0);
|
||||||
|
pub const Z:Self=Self::int(0,0,1);
|
||||||
|
pub const NEG_X:Self=Self::int(-1,0,0);
|
||||||
|
pub const NEG_Y:Self=Self::int(0,-1,0);
|
||||||
|
pub const NEG_Z:Self=Self::int(0,0,-1);
|
||||||
|
pub const MIN:Self=Planar64Vec3(glam::I64Vec3::MIN);
|
||||||
|
pub const MAX:Self=Planar64Vec3(glam::I64Vec3::MAX);
|
||||||
|
#[inline]
|
||||||
|
pub const fn int(x:i32,y:i32,z:i32)->Self{
|
||||||
|
Self(glam::i64vec3((x as i64)<<32,(y as i64)<<32,(z as i64)<<32))
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub const fn raw(x:i64,y:i64,z:i64)->Self{
|
||||||
|
Self(glam::i64vec3(x,y,z))
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn x(&self)->Planar64{
|
||||||
|
Planar64(self.0.x)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn y(&self)->Planar64{
|
||||||
|
Planar64(self.0.y)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn z(&self)->Planar64{
|
||||||
|
Planar64(self.0.z)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn min(&self,rhs:Self)->Self{
|
||||||
|
Self(glam::i64vec3(
|
||||||
|
self.0.x.min(rhs.0.x),
|
||||||
|
self.0.y.min(rhs.0.y),
|
||||||
|
self.0.z.min(rhs.0.z),
|
||||||
|
))
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn max(&self,rhs:Self)->Self{
|
||||||
|
Self(glam::i64vec3(
|
||||||
|
self.0.x.max(rhs.0.x),
|
||||||
|
self.0.y.max(rhs.0.y),
|
||||||
|
self.0.z.max(rhs.0.z),
|
||||||
|
))
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn midpoint(&self,rhs:Self)->Self{
|
||||||
|
Self((self.0+rhs.0)/2)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn cmplt(&self,rhs:Self)->glam::BVec3{
|
||||||
|
self.0.cmplt(rhs.0)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn dot(&self,rhs:Self)->Planar64{
|
||||||
|
Planar64(((
|
||||||
|
(self.0.x as i128)*(rhs.0.x as i128)+
|
||||||
|
(self.0.y as i128)*(rhs.0.y as i128)+
|
||||||
|
(self.0.z as i128)*(rhs.0.z as i128)
|
||||||
|
)>>32) as i64)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn length(&self)->Planar64{
|
||||||
|
let radicand=(self.0.x as i128)*(self.0.x as i128)+(self.0.y as i128)*(self.0.y as i128)+(self.0.z as i128)*(self.0.z as i128);
|
||||||
|
Planar64(unsafe{(radicand as f64).sqrt().to_int_unchecked()})
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn with_length(&self,length:Planar64)->Self{
|
||||||
|
let radicand=(self.0.x as i128)*(self.0.x as i128)+(self.0.y as i128)*(self.0.y as i128)+(self.0.z as i128)*(self.0.z as i128);
|
||||||
|
let self_length:i128=unsafe{(radicand as f64).sqrt().to_int_unchecked()};
|
||||||
|
//self.0*length/self_length
|
||||||
|
Planar64Vec3(
|
||||||
|
glam::i64vec3(
|
||||||
|
((self.0.x as i128)*(length.0 as i128)/self_length) as i64,
|
||||||
|
((self.0.y as i128)*(length.0 as i128)/self_length) as i64,
|
||||||
|
((self.0.z as i128)*(length.0 as i128)/self_length) as i64,
|
||||||
|
)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Into<glam::Vec3> for Planar64Vec3{
|
||||||
|
#[inline]
|
||||||
|
fn into(self)->glam::Vec3{
|
||||||
|
glam::vec3(
|
||||||
|
self.0.x as f32,
|
||||||
|
self.0.y as f32,
|
||||||
|
self.0.z as f32,
|
||||||
|
)*PLANAR64_CONVERT_TO_FLOAT32
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<[f32;3]> for Planar64Vec3{
|
||||||
|
type Error=Planar64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:[f32;3])->Result<Self,Self::Error>{
|
||||||
|
Ok(Self(glam::i64vec3(
|
||||||
|
Planar64::try_from(value[0])?.0,
|
||||||
|
Planar64::try_from(value[1])?.0,
|
||||||
|
Planar64::try_from(value[2])?.0,
|
||||||
|
)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<glam::Vec3A> for Planar64Vec3{
|
||||||
|
type Error=Planar64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:glam::Vec3A)->Result<Self,Self::Error>{
|
||||||
|
Ok(Self(glam::i64vec3(
|
||||||
|
Planar64::try_from(value.x)?.0,
|
||||||
|
Planar64::try_from(value.y)?.0,
|
||||||
|
Planar64::try_from(value.z)?.0,
|
||||||
|
)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::fmt::Display for Planar64Vec3{
|
||||||
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
|
write!(f,"{:.3},{:.3},{:.3}",
|
||||||
|
Into::<f32>::into(self.x()),Into::<f32>::into(self.y()),Into::<f32>::into(self.z()),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Neg for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn neg(self)->Self::Output{
|
||||||
|
Planar64Vec3(-self.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Add<Planar64Vec3> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn add(self,rhs:Planar64Vec3) -> Self::Output {
|
||||||
|
Planar64Vec3(self.0+rhs.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::AddAssign<Planar64Vec3> for Planar64Vec3{
|
||||||
|
#[inline]
|
||||||
|
fn add_assign(&mut self,rhs:Planar64Vec3){
|
||||||
|
*self=*self+rhs
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Sub<Planar64Vec3> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn sub(self,rhs:Planar64Vec3) -> Self::Output {
|
||||||
|
Planar64Vec3(self.0-rhs.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::SubAssign<Planar64Vec3> for Planar64Vec3{
|
||||||
|
#[inline]
|
||||||
|
fn sub_assign(&mut self,rhs:Planar64Vec3){
|
||||||
|
*self=*self-rhs
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Planar64Vec3> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self, rhs: Planar64Vec3) -> Self::Output {
|
||||||
|
Planar64Vec3(glam::i64vec3(
|
||||||
|
(((self.0.x as i128)*(rhs.0.x as i128))>>32) as i64,
|
||||||
|
(((self.0.y as i128)*(rhs.0.y as i128))>>32) as i64,
|
||||||
|
(((self.0.z as i128)*(rhs.0.z as i128))>>32) as i64
|
||||||
|
))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Planar64> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self, rhs: Planar64) -> Self::Output {
|
||||||
|
Planar64Vec3(glam::i64vec3(
|
||||||
|
(((self.0.x as i128)*(rhs.0 as i128))>>32) as i64,
|
||||||
|
(((self.0.y as i128)*(rhs.0 as i128))>>32) as i64,
|
||||||
|
(((self.0.z as i128)*(rhs.0 as i128))>>32) as i64
|
||||||
|
))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<i64> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:i64)->Self::Output {
|
||||||
|
Planar64Vec3(glam::i64vec3(
|
||||||
|
self.0.x*rhs,
|
||||||
|
self.0.y*rhs,
|
||||||
|
self.0.z*rhs
|
||||||
|
))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Time> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:Time)->Self::Output{
|
||||||
|
Planar64Vec3(glam::i64vec3(
|
||||||
|
(((self.0.x as i128)*(rhs.0 as i128))/1_000_000_000) as i64,
|
||||||
|
(((self.0.y as i128)*(rhs.0 as i128))/1_000_000_000) as i64,
|
||||||
|
(((self.0.z as i128)*(rhs.0 as i128))/1_000_000_000) as i64
|
||||||
|
))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Div<i64> for Planar64Vec3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn div(self,rhs:i64)->Self::Output{
|
||||||
|
Planar64Vec3(glam::i64vec3(
|
||||||
|
self.0.x/rhs,
|
||||||
|
self.0.y/rhs,
|
||||||
|
self.0.z/rhs,
|
||||||
|
))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
///[-1.0,1.0] = [-2^32,2^32]
|
||||||
|
#[derive(Clone,Copy)]
|
||||||
|
pub struct Planar64Mat3{
|
||||||
|
x_axis:Planar64Vec3,
|
||||||
|
y_axis:Planar64Vec3,
|
||||||
|
z_axis:Planar64Vec3,
|
||||||
|
}
|
||||||
|
impl Default for Planar64Mat3{
|
||||||
|
#[inline]
|
||||||
|
fn default() -> Self {
|
||||||
|
Self{
|
||||||
|
x_axis:Planar64Vec3::X,
|
||||||
|
y_axis:Planar64Vec3::Y,
|
||||||
|
z_axis:Planar64Vec3::Z,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Mul<Planar64Vec3> for Planar64Mat3{
|
||||||
|
type Output=Planar64Vec3;
|
||||||
|
#[inline]
|
||||||
|
fn mul(self,rhs:Planar64Vec3) -> Self::Output {
|
||||||
|
self.x_axis*rhs.x()
|
||||||
|
+self.y_axis*rhs.y()
|
||||||
|
+self.z_axis*rhs.z()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Planar64Mat3{
|
||||||
|
#[inline]
|
||||||
|
pub fn from_cols(x_axis:Planar64Vec3,y_axis:Planar64Vec3,z_axis:Planar64Vec3)->Self{
|
||||||
|
Self{
|
||||||
|
x_axis,
|
||||||
|
y_axis,
|
||||||
|
z_axis,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub const fn int_from_cols_array(array:[i32;9])->Self{
|
||||||
|
Self{
|
||||||
|
x_axis:Planar64Vec3::int(array[0],array[1],array[2]),
|
||||||
|
y_axis:Planar64Vec3::int(array[3],array[4],array[5]),
|
||||||
|
z_axis:Planar64Vec3::int(array[6],array[7],array[8]),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn from_rotation_yx(yaw:Angle32,pitch:Angle32)->Self{
|
||||||
|
let xtheta=yaw.0 as f64*ANGLE32_TO_FLOAT64_RADIANS;
|
||||||
|
let (xs,xc)=xtheta.sin_cos();
|
||||||
|
let (xc,xs)=(xc*PLANAR64_ONE_FLOAT64,xs*PLANAR64_ONE_FLOAT64);
|
||||||
|
let ytheta=pitch.0 as f64*ANGLE32_TO_FLOAT64_RADIANS;
|
||||||
|
let (ys,yc)=ytheta.sin_cos();
|
||||||
|
let (yc,ys)=(yc*PLANAR64_ONE_FLOAT64,ys*PLANAR64_ONE_FLOAT64);
|
||||||
|
//TODO: fix this rounding towards 0
|
||||||
|
let (xc,xs):(i64,i64)=(unsafe{xc.to_int_unchecked()},unsafe{xs.to_int_unchecked()});
|
||||||
|
let (yc,ys):(i64,i64)=(unsafe{yc.to_int_unchecked()},unsafe{ys.to_int_unchecked()});
|
||||||
|
Self::from_cols(
|
||||||
|
Planar64Vec3(glam::i64vec3(xc,0,-xs)),
|
||||||
|
Planar64Vec3(glam::i64vec3(((xs as i128*ys as i128)>>32) as i64,yc,((xc as i128*ys as i128)>>32) as i64)),
|
||||||
|
Planar64Vec3(glam::i64vec3(((xs as i128*yc as i128)>>32) as i64,-ys,((xc as i128*yc as i128)>>32) as i64)),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn from_rotation_y(angle:Angle32)->Self{
|
||||||
|
let theta=angle.0 as f64*ANGLE32_TO_FLOAT64_RADIANS;
|
||||||
|
let (s,c)=theta.sin_cos();
|
||||||
|
let (c,s)=(c*PLANAR64_ONE_FLOAT64,s*PLANAR64_ONE_FLOAT64);
|
||||||
|
//TODO: fix this rounding towards 0
|
||||||
|
let (c,s):(i64,i64)=(unsafe{c.to_int_unchecked()},unsafe{s.to_int_unchecked()});
|
||||||
|
Self::from_cols(
|
||||||
|
Planar64Vec3(glam::i64vec3(c,0,-s)),
|
||||||
|
Planar64Vec3::Y,
|
||||||
|
Planar64Vec3(glam::i64vec3(s,0,c)),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Into<glam::Mat3> for Planar64Mat3{
|
||||||
|
#[inline]
|
||||||
|
fn into(self)->glam::Mat3{
|
||||||
|
glam::Mat3::from_cols(
|
||||||
|
self.x_axis.into(),
|
||||||
|
self.y_axis.into(),
|
||||||
|
self.z_axis.into(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<glam::Mat3A> for Planar64Mat3{
|
||||||
|
type Error=Planar64TryFromFloatError;
|
||||||
|
#[inline]
|
||||||
|
fn try_from(value:glam::Mat3A)->Result<Self,Self::Error>{
|
||||||
|
Ok(Self{
|
||||||
|
x_axis:Planar64Vec3::try_from(value.x_axis)?,
|
||||||
|
y_axis:Planar64Vec3::try_from(value.y_axis)?,
|
||||||
|
z_axis:Planar64Vec3::try_from(value.z_axis)?,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::fmt::Display for Planar64Mat3{
|
||||||
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
|
write!(f,"\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}",
|
||||||
|
Into::<f32>::into(self.x_axis.x()),Into::<f32>::into(self.x_axis.y()),Into::<f32>::into(self.x_axis.z()),
|
||||||
|
Into::<f32>::into(self.y_axis.x()),Into::<f32>::into(self.y_axis.y()),Into::<f32>::into(self.y_axis.z()),
|
||||||
|
Into::<f32>::into(self.z_axis.x()),Into::<f32>::into(self.z_axis.y()),Into::<f32>::into(self.z_axis.z()),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::ops::Div<i64> for Planar64Mat3{
|
||||||
|
type Output=Planar64Mat3;
|
||||||
|
#[inline]
|
||||||
|
fn div(self,rhs:i64)->Self::Output{
|
||||||
|
Planar64Mat3{
|
||||||
|
x_axis:self.x_axis/rhs,
|
||||||
|
y_axis:self.y_axis/rhs,
|
||||||
|
z_axis:self.z_axis/rhs,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
///[-1.0,1.0] = [-2^32,2^32]
|
||||||
|
#[derive(Clone,Copy,Default)]
|
||||||
|
pub struct Planar64Affine3{
|
||||||
|
pub matrix3:Planar64Mat3,//includes scale above 1
|
||||||
|
pub translation:Planar64Vec3,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Planar64Affine3{
|
||||||
|
#[inline]
|
||||||
|
pub fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
|
||||||
|
Self{matrix3,translation}
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
pub fn transform_point3(&self,point:Planar64Vec3) -> Planar64Vec3{
|
||||||
|
Planar64Vec3(
|
||||||
|
self.translation.0
|
||||||
|
+(self.matrix3.x_axis*point.x()).0
|
||||||
|
+(self.matrix3.y_axis*point.y()).0
|
||||||
|
+(self.matrix3.z_axis*point.z()).0
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Into<glam::Mat4> for Planar64Affine3{
|
||||||
|
#[inline]
|
||||||
|
fn into(self)->glam::Mat4{
|
||||||
|
glam::Mat4::from_cols_array(&[
|
||||||
|
self.matrix3.x_axis.0.x as f32,self.matrix3.x_axis.0.y as f32,self.matrix3.x_axis.0.z as f32,0.0,
|
||||||
|
self.matrix3.y_axis.0.x as f32,self.matrix3.y_axis.0.y as f32,self.matrix3.y_axis.0.z as f32,0.0,
|
||||||
|
self.matrix3.z_axis.0.x as f32,self.matrix3.z_axis.0.y as f32,self.matrix3.z_axis.0.z as f32,0.0,
|
||||||
|
self.translation.0.x as f32,self.translation.0.y as f32,self.translation.0.z as f32,PLANAR64_ONE_FLOAT32
|
||||||
|
])*PLANAR64_CONVERT_TO_FLOAT32
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl TryFrom<glam::Affine3A> for Planar64Affine3{
|
||||||
|
type Error=Planar64TryFromFloatError;
|
||||||
|
fn try_from(value: glam::Affine3A)->Result<Self, Self::Error> {
|
||||||
|
Ok(Self{
|
||||||
|
matrix3:Planar64Mat3::try_from(value.matrix3)?,
|
||||||
|
translation:Planar64Vec3::try_from(value.translation)?
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl std::fmt::Display for Planar64Affine3{
|
||||||
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
||||||
|
write!(f,"translation: {:.3},{:.3},{:.3}\nmatrix3:\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}",
|
||||||
|
Into::<f32>::into(self.translation.x()),Into::<f32>::into(self.translation.y()),Into::<f32>::into(self.translation.z()),
|
||||||
|
Into::<f32>::into(self.matrix3.x_axis.x()),Into::<f32>::into(self.matrix3.x_axis.y()),Into::<f32>::into(self.matrix3.x_axis.z()),
|
||||||
|
Into::<f32>::into(self.matrix3.y_axis.x()),Into::<f32>::into(self.matrix3.y_axis.y()),Into::<f32>::into(self.matrix3.y_axis.z()),
|
||||||
|
Into::<f32>::into(self.matrix3.z_axis.x()),Into::<f32>::into(self.matrix3.z_axis.y()),Into::<f32>::into(self.matrix3.z_axis.z()),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_sqrt(){
|
||||||
|
let r=Planar64::int(400);
|
||||||
|
println!("r{}",r.get());
|
||||||
|
let s=r.sqrt();
|
||||||
|
println!("s{}",s.get());
|
||||||
|
}
|
232
src/load_bsp.rs
232
src/load_bsp.rs
@ -1,232 +0,0 @@
|
|||||||
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 strafesnet_common::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
|
use crate::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,18 +14,23 @@ 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){
|
||||||
let mut stack=vec![instance];
|
for &referent in instance.children() {
|
||||||
while let Some(item)=stack.pop(){
|
if let Some(c) = dom.get_by_ref(referent) {
|
||||||
for &referent in item.children(){
|
if class_is_a(c.class.as_str(), superclass) {
|
||||||
if let Some(c)=dom.get_by_ref(referent){
|
|
||||||
if class_is_a(c.class.as_str(),superclass){
|
|
||||||
objects.push(c.referent());//copy ref
|
objects.push(c.referent());//copy ref
|
||||||
}
|
}
|
||||||
stack.push(c);
|
recursive_collect_superclass(objects,dom,c,superclass);
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
|
||||||
|
let mut objects = std::vec::Vec::new();
|
||||||
|
recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
|
||||||
|
//get ids
|
||||||
|
//clear vec
|
||||||
|
//next class
|
||||||
|
objects
|
||||||
|
}
|
||||||
fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
|
fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
|
||||||
Planar64Affine3::new(
|
Planar64Affine3::new(
|
||||||
Planar64Mat3::from_cols(
|
Planar64Mat3::from_cols(
|
||||||
@ -48,19 +53,13 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
|
|||||||
"Water"=>{
|
"Water"=>{
|
||||||
force_can_collide=false;
|
force_can_collide=false;
|
||||||
//TODO: read stupid CustomPhysicalProperties
|
//TODO: read stupid CustomPhysicalProperties
|
||||||
intersecting.water=Some(crate::model::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
|
intersecting.water=Some(crate::model::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,current:velocity});
|
||||||
},
|
},
|
||||||
"Accelerator"=>{
|
"Accelerator"=>{
|
||||||
//although the new game supports collidable accelerators, this is a roblox compatability map loader
|
//although the new game supports collidable accelerators, this is a roblox compatability map loader
|
||||||
force_can_collide=false;
|
force_can_collide=false;
|
||||||
general.accelerator=Some(crate::model::GameMechanicAccelerator{acceleration:velocity});
|
general.accelerator=Some(crate::model::GameMechanicAccelerator{acceleration:velocity});
|
||||||
},
|
},
|
||||||
// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
|
|
||||||
// mode_id:0,
|
|
||||||
// stage_id:0,
|
|
||||||
// force:false,
|
|
||||||
// behaviour:crate::model::StageElementBehaviour::Unordered
|
|
||||||
// })),
|
|
||||||
"SetVelocity"=>general.trajectory=Some(crate::model::GameMechanicSetTrajectory::Velocity(velocity)),
|
"SetVelocity"=>general.trajectory=Some(crate::model::GameMechanicSetTrajectory::Velocity(velocity)),
|
||||||
"MapFinish"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish})},
|
"MapFinish"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish})},
|
||||||
"MapAnticheat"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat})},
|
"MapAnticheat"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat})},
|
||||||
@ -120,13 +119,6 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
|
|||||||
_=>panic!("regex3[1] messed up bad"),
|
_=>panic!("regex3[1] messed up bad"),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// else if let Some(captures)=lazy_regex::regex!(r"^(OrderedCheckpoint)(\d+)$")
|
|
||||||
// .captures(other){
|
|
||||||
// match &captures[1]{
|
|
||||||
// "OrderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Ordered{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()}),
|
|
||||||
// _=>panic!("regex3[1] messed up bad"),
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
//need some way to skip this
|
//need some way to skip this
|
||||||
@ -226,9 +218,9 @@ type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
|
|||||||
type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
|
type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
|
||||||
#[derive(Clone,Eq,Hash,PartialEq)]
|
#[derive(Clone,Eq,Hash,PartialEq)]
|
||||||
enum RobloxBasePartDescription{
|
enum RobloxBasePartDescription{
|
||||||
Sphere(RobloxPartDescription),
|
Sphere,
|
||||||
Part(RobloxPartDescription),
|
Part(RobloxPartDescription),
|
||||||
Cylinder(RobloxPartDescription),
|
Cylinder,
|
||||||
Wedge(RobloxWedgeDescription),
|
Wedge(RobloxWedgeDescription),
|
||||||
CornerWedge(RobloxCornerWedgeDescription),
|
CornerWedge(RobloxCornerWedgeDescription),
|
||||||
}
|
}
|
||||||
@ -265,18 +257,6 @@ 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();
|
||||||
@ -285,12 +265,14 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
spawn_point=model_transform.transform_point3(Planar64Vec3::ZERO)+Planar64Vec3::Y*5/2;
|
spawn_point=model_transform.transform_point3(Planar64Vec3::ZERO)+Planar64Vec3::Y*5/2;
|
||||||
Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:0}))
|
Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:0}))
|
||||||
},
|
},
|
||||||
|
"UnorderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::UnorderedCheckpoint(crate::model::TempAttrUnorderedCheckpoint{mode_id:0})),
|
||||||
other=>{
|
other=>{
|
||||||
let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|WormholeOut)(\d+)$");
|
let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|OrderedCheckpoint|WormholeOut)(\d+)$");
|
||||||
if let Some(captures) = regman.captures(other) {
|
if let Some(captures) = regman.captures(other) {
|
||||||
match &captures[1]{
|
match &captures[1]{
|
||||||
"BonusStart"=>Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:captures[2].parse::<u32>().unwrap()})),
|
"BonusStart"=>Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:captures[2].parse::<u32>().unwrap()})),
|
||||||
"Spawn"|"ForceSpawn"=>Some(crate::model::TempIndexedAttributes::Spawn(crate::model::TempAttrSpawn{mode_id:0,stage_id:captures[2].parse::<u32>().unwrap()})),
|
"Spawn"|"ForceSpawn"=>Some(crate::model::TempIndexedAttributes::Spawn(crate::model::TempAttrSpawn{mode_id:0,stage_id:captures[2].parse::<u32>().unwrap()})),
|
||||||
|
"OrderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::OrderedCheckpoint(crate::model::TempAttrOrderedCheckpoint{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()})),
|
||||||
"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
|
"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
|
||||||
_=>None,
|
_=>None,
|
||||||
}
|
}
|
||||||
@ -319,7 +301,6 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
panic!("Part has no Shape!");
|
panic!("Part has no Shape!");
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"TrussPart"=>primitives::Primitives::Cube,
|
|
||||||
"WedgePart"=>primitives::Primitives::Wedge,
|
"WedgePart"=>primitives::Primitives::Wedge,
|
||||||
"CornerWedgePart"=>primitives::Primitives::CornerWedge,
|
"CornerWedgePart"=>primitives::Primitives::CornerWedge,
|
||||||
_=>{
|
_=>{
|
||||||
@ -414,9 +395,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
f5,//Cube::Front
|
f5,//Cube::Front
|
||||||
]=part_texture_description;
|
]=part_texture_description;
|
||||||
let basepart_texture_description=match shape{
|
let basepart_texture_description=match shape{
|
||||||
primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere([f0,f1,f2,f3,f4,f5]),
|
primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere,
|
||||||
primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
|
primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
|
||||||
primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder([f0,f1,f2,f3,f4,f5]),
|
primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder,
|
||||||
//use front face texture first and use top face texture as a fallback
|
//use front face texture first and use top face texture as a fallback
|
||||||
primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
|
primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
|
||||||
f0,//Cube::Right->Wedge::Right
|
f0,//Cube::Right->Wedge::Right
|
||||||
@ -442,10 +423,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
let model_id=indexed_models.len();
|
let model_id=indexed_models.len();
|
||||||
model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
|
model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
|
||||||
indexed_models.push(match basepart_texture_description{
|
indexed_models.push(match basepart_texture_description{
|
||||||
RobloxBasePartDescription::Sphere(part_texture_description)
|
RobloxBasePartDescription::Sphere=>primitives::unit_sphere(),
|
||||||
|RobloxBasePartDescription::Cylinder(part_texture_description)
|
RobloxBasePartDescription::Part(part_texture_description)=>{
|
||||||
|RobloxBasePartDescription::Part(part_texture_description)=>{
|
let mut cube_face_description=primitives::CubeFaceDescription::new();
|
||||||
let mut cube_face_description=primitives::CubeFaceDescription::default();
|
|
||||||
for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
|
for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
|
||||||
cube_face_description.insert(
|
cube_face_description.insert(
|
||||||
match face_id{
|
match face_id{
|
||||||
@ -464,8 +444,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
}
|
}
|
||||||
primitives::generate_partial_unit_cube(cube_face_description)
|
primitives::generate_partial_unit_cube(cube_face_description)
|
||||||
},
|
},
|
||||||
|
RobloxBasePartDescription::Cylinder=>primitives::unit_cylinder(),
|
||||||
RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
|
RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
|
||||||
let mut wedge_face_description=primitives::WedgeFaceDescription::default();
|
let mut wedge_face_description=primitives::WedgeFaceDescription::new();
|
||||||
for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
|
for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
|
||||||
wedge_face_description.insert(
|
wedge_face_description.insert(
|
||||||
match face_id{
|
match face_id{
|
||||||
@ -484,7 +465,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
|
|||||||
primitives::generate_partial_unit_wedge(wedge_face_description)
|
primitives::generate_partial_unit_wedge(wedge_face_description)
|
||||||
},
|
},
|
||||||
RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
|
RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
|
||||||
let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::default();
|
let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::new();
|
||||||
for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
|
for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
|
||||||
cornerwedge_face_description.insert(
|
cornerwedge_face_description.insert(
|
||||||
match face_id{
|
match face_id{
|
||||||
|
1353
src/main.rs
1353
src/main.rs
File diff suppressed because it is too large
Load Diff
105
src/model.rs
105
src/model.rs
@ -1,4 +1,4 @@
|
|||||||
use strafesnet_common::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
|
use crate::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)]
|
||||||
@ -50,10 +50,10 @@ pub struct IndexedModelInstances{
|
|||||||
}
|
}
|
||||||
//stage description referencing flattened ids is spooky, but the map loading is meant to be deterministic.
|
//stage description referencing flattened ids is spooky, but the map loading is meant to be deterministic.
|
||||||
pub struct ModeDescription{
|
pub struct ModeDescription{
|
||||||
//TODO: put "default" style modifiers in mode
|
|
||||||
//pub style:StyleModifiers,
|
|
||||||
pub start:usize,//start=model_id
|
pub start:usize,//start=model_id
|
||||||
pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
|
pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
|
||||||
|
pub ordered_checkpoints:Vec<usize>,//ordered_checkpoints[checkpoint_id]=model_id
|
||||||
|
pub unordered_checkpoints:Vec<usize>,//unordered_checkpoints[checkpoint_id]=model_id
|
||||||
pub spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
|
pub spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
|
||||||
pub ordered_checkpoint_from_checkpoint_id:std::collections::HashMap::<u32,usize>,
|
pub ordered_checkpoint_from_checkpoint_id:std::collections::HashMap::<u32,usize>,
|
||||||
}
|
}
|
||||||
@ -61,6 +61,9 @@ impl ModeDescription{
|
|||||||
pub fn get_spawn_model_id(&self,stage_id:u32)->Option<&usize>{
|
pub fn get_spawn_model_id(&self,stage_id:u32)->Option<&usize>{
|
||||||
self.spawns.get(*self.spawn_from_stage_id.get(&stage_id)?)
|
self.spawns.get(*self.spawn_from_stage_id.get(&stage_id)?)
|
||||||
}
|
}
|
||||||
|
pub fn get_ordered_checkpoint_model_id(&self,checkpoint_id:u32)->Option<&usize>{
|
||||||
|
self.ordered_checkpoints.get(*self.ordered_checkpoint_from_checkpoint_id.get(&checkpoint_id)?)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
//I don't want this code to exist!
|
//I don't want this code to exist!
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
@ -73,88 +76,84 @@ pub struct TempAttrSpawn{
|
|||||||
pub stage_id:u32,
|
pub stage_id:u32,
|
||||||
}
|
}
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
|
pub struct TempAttrOrderedCheckpoint{
|
||||||
|
pub mode_id:u32,
|
||||||
|
pub checkpoint_id:u32,
|
||||||
|
}
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct TempAttrUnorderedCheckpoint{
|
||||||
|
pub mode_id:u32,
|
||||||
|
}
|
||||||
|
#[derive(Clone)]
|
||||||
pub struct TempAttrWormhole{
|
pub struct TempAttrWormhole{
|
||||||
pub wormhole_id:u32,
|
pub wormhole_id:u32,
|
||||||
}
|
}
|
||||||
pub enum TempIndexedAttributes{
|
pub enum TempIndexedAttributes{
|
||||||
Start(TempAttrStart),
|
Start(TempAttrStart),
|
||||||
Spawn(TempAttrSpawn),
|
Spawn(TempAttrSpawn),
|
||||||
|
OrderedCheckpoint(TempAttrOrderedCheckpoint),
|
||||||
|
UnorderedCheckpoint(TempAttrUnorderedCheckpoint),
|
||||||
Wormhole(TempAttrWormhole),
|
Wormhole(TempAttrWormhole),
|
||||||
}
|
}
|
||||||
|
|
||||||
//you have this effect while in contact
|
//you have this effect while in contact
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub struct ContactingLadder{
|
pub struct ContactingLadder{
|
||||||
pub sticky:bool
|
pub sticky:bool
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub enum ContactingBehaviour{
|
pub enum ContactingBehaviour{
|
||||||
Surf,
|
Surf,
|
||||||
Cling,//usable as a zipline, or other weird and wonderful things
|
|
||||||
Ladder(ContactingLadder),
|
Ladder(ContactingLadder),
|
||||||
Elastic(u32),//[1/2^32,1] 0=None (elasticity+1)/2^32
|
Elastic(u32),//[1/2^32,1] 0=None (elasticity+1)/2^32
|
||||||
}
|
}
|
||||||
//you have this effect while intersecting
|
//you have this effect while intersecting
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub struct IntersectingWater{
|
pub struct IntersectingWater{
|
||||||
pub viscosity:Planar64,
|
pub viscosity:Planar64,
|
||||||
pub density:Planar64,
|
pub density:Planar64,
|
||||||
pub velocity:Planar64Vec3,
|
pub current:Planar64Vec3,
|
||||||
}
|
}
|
||||||
//All models can be given these attributes
|
//All models can be given these attributes
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub struct GameMechanicAccelerator{
|
pub struct GameMechanicAccelerator{
|
||||||
pub acceleration:Planar64Vec3
|
pub acceleration:Planar64Vec3
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub enum GameMechanicBooster{
|
pub enum GameMechanicBooster{
|
||||||
Affine(Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
|
Affine(Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
|
||||||
Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
|
Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
|
||||||
Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
|
Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub enum TrajectoryChoice{
|
pub enum TrajectoryChoice{
|
||||||
HighArcLongDuration,//underhand lob at target: less horizontal speed and more air time
|
HighArcLongDuration,//underhand lob at target: less horizontal speed and more air time
|
||||||
LowArcShortDuration,//overhand throw at target: more horizontal speed and less air time
|
LowArcShortDuration,//overhand throw at target: more horizontal speed and less air time
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub enum GameMechanicSetTrajectory{
|
pub enum GameMechanicSetTrajectory{
|
||||||
//Speed-type SetTrajectory
|
|
||||||
AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
|
AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
|
||||||
Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
|
Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
|
||||||
DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
|
|
||||||
//Velocity-type SetTrajectory
|
|
||||||
TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
|
TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
|
||||||
target_point:Planar64Vec3,
|
target_point:Planar64Vec3,
|
||||||
time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
|
time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
|
||||||
},
|
},
|
||||||
TargetPointSpeed{//launch at a fixed speed and land at a target point
|
TrajectoryTargetPoint{//launch at a fixed speed and land at a target point
|
||||||
target_point:Planar64Vec3,
|
target_point:Planar64Vec3,
|
||||||
speed:Planar64,//if speed is too low this will fail to reach the target. The closest-passing trajectory will be chosen instead
|
speed:Planar64,//if speed is too low this will fail to reach the target. The closest-passing trajectory will be chosen instead
|
||||||
trajectory_choice:TrajectoryChoice,
|
trajectory_choice:TrajectoryChoice,
|
||||||
},
|
},
|
||||||
Velocity(Planar64Vec3),//SetVelocity
|
Velocity(Planar64Vec3),//SetVelocity
|
||||||
|
DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
|
||||||
}
|
}
|
||||||
impl GameMechanicSetTrajectory{
|
#[derive(Clone)]
|
||||||
fn is_velocity(&self)->bool{
|
|
||||||
match self{
|
|
||||||
GameMechanicSetTrajectory::AirTime(_)
|
|
||||||
|GameMechanicSetTrajectory::Height(_)
|
|
||||||
|GameMechanicSetTrajectory::DotVelocity{direction:_,dot:_}=>false,
|
|
||||||
GameMechanicSetTrajectory::TargetPointTime{target_point:_,time:_}
|
|
||||||
|GameMechanicSetTrajectory::TargetPointSpeed{target_point:_,speed:_,trajectory_choice:_}
|
|
||||||
|GameMechanicSetTrajectory::Velocity(_)=>true,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
|
||||||
pub enum ZoneBehaviour{
|
pub enum ZoneBehaviour{
|
||||||
//Start is indexed
|
//Start is indexed
|
||||||
//Checkpoints are indexed
|
//Checkpoints are indexed
|
||||||
Finish,
|
Finish,
|
||||||
Anitcheat,
|
Anitcheat,
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub struct GameMechanicZone{
|
pub struct GameMechanicZone{
|
||||||
pub mode_id:u32,
|
pub mode_id:u32,
|
||||||
pub behaviour:ZoneBehaviour,
|
pub behaviour:ZoneBehaviour,
|
||||||
@ -165,36 +164,24 @@ pub struct GameMechanicZone{
|
|||||||
// InRange(Planar64,Planar64),
|
// InRange(Planar64,Planar64),
|
||||||
// OutsideRange(Planar64,Planar64),
|
// OutsideRange(Planar64,Planar64),
|
||||||
// }
|
// }
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub enum StageElementBehaviour{
|
pub enum StageElementBehaviour{
|
||||||
//Spawn,//The behaviour of stepping on a spawn setting the spawnid
|
//Spawn,//The behaviour of stepping on a spawn setting the spawnid
|
||||||
SpawnAt,//must be standing on top to get effect. except cancollide false
|
SpawnAt,
|
||||||
Trigger,
|
Trigger,
|
||||||
Teleport,
|
Teleport,
|
||||||
Platform,
|
Platform,
|
||||||
//Checkpoint acts like a trigger if you haven't hit all the checkpoints yet.
|
|
||||||
//Note that all stage elements act like this for the next stage.
|
|
||||||
Checkpoint,
|
|
||||||
//OrderedCheckpoint. You must pass through all of these in ascending order.
|
|
||||||
//If you hit them out of order it acts like a trigger.
|
|
||||||
//Do not support backtracking at all for now.
|
|
||||||
Ordered{
|
|
||||||
checkpoint_id:u32,
|
|
||||||
},
|
|
||||||
//UnorderedCheckpoint. You must pass through all of these in any order.
|
|
||||||
Unordered,
|
|
||||||
//If you get reset by a jump limit
|
|
||||||
JumpLimit(u32),
|
JumpLimit(u32),
|
||||||
//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
|
//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub struct GameMechanicStageElement{
|
pub struct GameMechanicStageElement{
|
||||||
pub mode_id:u32,
|
pub mode_id:u32,
|
||||||
pub stage_id:u32,//which spawn to send to
|
pub stage_id:u32,//which spawn to send to
|
||||||
pub force:bool,//allow setting to lower spawn id i.e. 7->3
|
pub force:bool,//allow setting to lower spawn id i.e. 7->3
|
||||||
pub behaviour:StageElementBehaviour
|
pub behaviour:StageElementBehaviour
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub struct GameMechanicWormhole{
|
pub struct GameMechanicWormhole{
|
||||||
//destination does not need to be another wormhole
|
//destination does not need to be another wormhole
|
||||||
//this defines a one way portal to a destination model transform
|
//this defines a one way portal to a destination model transform
|
||||||
@ -202,13 +189,13 @@ pub struct GameMechanicWormhole{
|
|||||||
pub destination_model_id:u32,
|
pub destination_model_id:u32,
|
||||||
//(position,angles)*=origin.transform.inverse()*destination.transform
|
//(position,angles)*=origin.transform.inverse()*destination.transform
|
||||||
}
|
}
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
#[derive(Clone)]
|
||||||
pub enum TeleportBehaviour{
|
pub enum TeleportBehaviour{
|
||||||
StageElement(GameMechanicStageElement),
|
StageElement(GameMechanicStageElement),
|
||||||
Wormhole(GameMechanicWormhole),
|
Wormhole(GameMechanicWormhole),
|
||||||
}
|
}
|
||||||
//attributes listed in order of handling
|
//attributes listed in order of handling
|
||||||
#[derive(Default,Clone,Hash,Eq,PartialEq)]
|
#[derive(Default,Clone)]
|
||||||
pub struct GameMechanicAttributes{
|
pub struct GameMechanicAttributes{
|
||||||
pub zone:Option<GameMechanicZone>,
|
pub zone:Option<GameMechanicZone>,
|
||||||
pub booster:Option<GameMechanicBooster>,
|
pub booster:Option<GameMechanicBooster>,
|
||||||
@ -218,28 +205,14 @@ pub struct GameMechanicAttributes{
|
|||||||
}
|
}
|
||||||
impl GameMechanicAttributes{
|
impl GameMechanicAttributes{
|
||||||
pub fn any(&self)->bool{
|
pub fn any(&self)->bool{
|
||||||
self.zone.is_some()
|
self.booster.is_some()
|
||||||
||self.booster.is_some()
|
|
||||||
||self.trajectory.is_some()
|
||self.trajectory.is_some()
|
||||||
|
||self.zone.is_some()
|
||||||
||self.teleport_behaviour.is_some()
|
||self.teleport_behaviour.is_some()
|
||||||
||self.accelerator.is_some()
|
||self.accelerator.is_some()
|
||||||
}
|
}
|
||||||
pub fn is_wrcp(&self,current_mode_id:u32)->bool{
|
|
||||||
self.trajectory.as_ref().map_or(false,|t|t.is_velocity())
|
|
||||||
&&match &self.teleport_behaviour{
|
|
||||||
Some(TeleportBehaviour::StageElement(
|
|
||||||
GameMechanicStageElement{
|
|
||||||
mode_id,
|
|
||||||
stage_id:_,
|
|
||||||
force:true,
|
|
||||||
behaviour:StageElementBehaviour::Trigger|StageElementBehaviour::Teleport
|
|
||||||
}
|
|
||||||
))=>current_mode_id==*mode_id,
|
|
||||||
_=>false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
#[derive(Default,Clone,Hash,Eq,PartialEq)]
|
#[derive(Default,Clone)]
|
||||||
pub struct ContactingAttributes{
|
pub struct ContactingAttributes{
|
||||||
//friction?
|
//friction?
|
||||||
pub contact_behaviour:Option<ContactingBehaviour>,
|
pub contact_behaviour:Option<ContactingBehaviour>,
|
||||||
@ -249,7 +222,7 @@ impl ContactingAttributes{
|
|||||||
self.contact_behaviour.is_some()
|
self.contact_behaviour.is_some()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[derive(Default,Clone,Hash,Eq,PartialEq)]
|
#[derive(Default,Clone)]
|
||||||
pub struct IntersectingAttributes{
|
pub struct IntersectingAttributes{
|
||||||
pub water:Option<IntersectingWater>,
|
pub water:Option<IntersectingWater>,
|
||||||
}
|
}
|
||||||
|
@ -11,7 +11,7 @@ pub struct GraphicsVertex {
|
|||||||
pub struct IndexedGroupFixedTexture{
|
pub struct IndexedGroupFixedTexture{
|
||||||
pub polys:Vec<IndexedPolygon>,
|
pub polys:Vec<IndexedPolygon>,
|
||||||
}
|
}
|
||||||
pub struct IndexedGraphicsModelSingleTexture{
|
pub struct IndexedModelGraphicsSingleTexture{
|
||||||
pub unique_pos:Vec<[f32; 3]>,
|
pub unique_pos:Vec<[f32; 3]>,
|
||||||
pub unique_tex:Vec<[f32; 2]>,
|
pub unique_tex:Vec<[f32; 2]>,
|
||||||
pub unique_normal:Vec<[f32; 3]>,
|
pub unique_normal:Vec<[f32; 3]>,
|
||||||
@ -19,41 +19,37 @@ pub struct IndexedGraphicsModelSingleTexture{
|
|||||||
pub unique_vertices:Vec<IndexedVertex>,
|
pub unique_vertices:Vec<IndexedVertex>,
|
||||||
pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
|
pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
|
||||||
pub groups: Vec<IndexedGroupFixedTexture>,
|
pub groups: Vec<IndexedGroupFixedTexture>,
|
||||||
pub instances:Vec<GraphicsModelInstance>,
|
pub instances:Vec<ModelGraphicsInstance>,
|
||||||
}
|
}
|
||||||
pub enum Entities{
|
pub struct ModelGraphicsSingleTexture{
|
||||||
U32(Vec<Vec<u32>>),
|
pub instances: Vec<ModelGraphicsInstance>,
|
||||||
U16(Vec<Vec<u16>>),
|
pub vertices: Vec<GraphicsVertex>,
|
||||||
}
|
pub entities: Vec<Vec<u16>>,
|
||||||
pub struct GraphicsModelSingleTexture{
|
pub texture: Option<u32>,
|
||||||
pub instances:Vec<GraphicsModelInstance>,
|
|
||||||
pub vertices:Vec<GraphicsVertex>,
|
|
||||||
pub entities:Entities,
|
|
||||||
pub texture:Option<u32>,
|
|
||||||
}
|
}
|
||||||
#[derive(Clone,PartialEq)]
|
#[derive(Clone,PartialEq)]
|
||||||
pub struct GraphicsModelColor4(glam::Vec4);
|
pub struct ModelGraphicsColor4(glam::Vec4);
|
||||||
impl GraphicsModelColor4{
|
impl ModelGraphicsColor4{
|
||||||
pub const fn get(&self)->glam::Vec4{
|
pub const fn get(&self)->glam::Vec4{
|
||||||
self.0
|
self.0
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl From<glam::Vec4> for GraphicsModelColor4{
|
impl From<glam::Vec4> for ModelGraphicsColor4{
|
||||||
fn from(value:glam::Vec4)->Self{
|
fn from(value:glam::Vec4)->Self{
|
||||||
Self(value)
|
Self(value)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl std::hash::Hash for GraphicsModelColor4{
|
impl std::hash::Hash for ModelGraphicsColor4{
|
||||||
fn hash<H: std::hash::Hasher>(&self,state:&mut H) {
|
fn hash<H: std::hash::Hasher>(&self,state:&mut H) {
|
||||||
for &f in self.0.as_ref(){
|
for &f in self.0.as_ref(){
|
||||||
bytemuck::cast::<f32,u32>(f).hash(state);
|
bytemuck::cast::<f32,u32>(f).hash(state);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl Eq for GraphicsModelColor4{}
|
impl Eq for ModelGraphicsColor4{}
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct GraphicsModelInstance{
|
pub struct ModelGraphicsInstance{
|
||||||
pub transform:glam::Mat4,
|
pub transform:glam::Mat4,
|
||||||
pub normal_transform:glam::Mat3,
|
pub normal_transform:glam::Mat3,
|
||||||
pub color:GraphicsModelColor4,
|
pub color:ModelGraphicsColor4,
|
||||||
}
|
}
|
@ -1,745 +1 @@
|
|||||||
use std::borrow::{Borrow,Cow};
|
//
|
||||||
use strafesnet_common::zeroes;
|
|
||||||
use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
|
|
||||||
|
|
||||||
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
|
||||||
pub struct VertId(usize);
|
|
||||||
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
|
||||||
pub struct EdgeId(usize);
|
|
||||||
pub trait UndirectedEdge{
|
|
||||||
type DirectedEdge:Copy+DirectedEdge;
|
|
||||||
fn as_directed(&self,parity:bool)->Self::DirectedEdge;
|
|
||||||
}
|
|
||||||
impl UndirectedEdge for EdgeId{
|
|
||||||
type DirectedEdge=DirectedEdgeId;
|
|
||||||
fn as_directed(&self,parity:bool)->DirectedEdgeId{
|
|
||||||
DirectedEdgeId(self.0|((parity as usize)<<(usize::BITS-1)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub trait DirectedEdge{
|
|
||||||
type UndirectedEdge:Copy+UndirectedEdge;
|
|
||||||
fn as_undirected(&self)->Self::UndirectedEdge;
|
|
||||||
fn parity(&self)->bool;
|
|
||||||
//this is stupid but may work fine
|
|
||||||
fn reverse(&self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
|
|
||||||
self.as_undirected().as_directed(!self.parity())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// DirectedEdgeId refers to an EdgeId when undirected.
|
|
||||||
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
|
||||||
pub struct DirectedEdgeId(usize);
|
|
||||||
impl DirectedEdge for DirectedEdgeId{
|
|
||||||
type UndirectedEdge=EdgeId;
|
|
||||||
fn as_undirected(&self)->EdgeId{
|
|
||||||
EdgeId(self.0&!(1<<(usize::BITS-1)))
|
|
||||||
}
|
|
||||||
fn parity(&self)->bool{
|
|
||||||
self.0&(1<<(usize::BITS-1))!=0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
|
||||||
pub struct FaceId(usize);
|
|
||||||
|
|
||||||
//Vertex <-> Edge <-> Face -> Collide
|
|
||||||
pub enum FEV<F,E:DirectedEdge,V>{
|
|
||||||
Face(F),
|
|
||||||
Edge(E::UndirectedEdge),
|
|
||||||
Vert(V),
|
|
||||||
}
|
|
||||||
|
|
||||||
//use Unit32 #[repr(C)] for map files
|
|
||||||
struct Face{
|
|
||||||
normal:Planar64Vec3,
|
|
||||||
dot:Planar64,
|
|
||||||
}
|
|
||||||
struct Vert(Planar64Vec3);
|
|
||||||
pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
|
|
||||||
fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
|
|
||||||
let verts=self.edge_verts(edge_id);
|
|
||||||
self.vert(verts[1].clone())-self.vert(verts[0].clone())
|
|
||||||
}
|
|
||||||
fn directed_edge_n(&self,directed_edge_id:EDGE)->Planar64Vec3{
|
|
||||||
let verts=self.edge_verts(directed_edge_id.as_undirected());
|
|
||||||
(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
|
|
||||||
}
|
|
||||||
fn vert(&self,vert_id:VERT)->Planar64Vec3;
|
|
||||||
fn face_nd(&self,face_id:FACE)->(Planar64Vec3,Planar64);
|
|
||||||
fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
|
|
||||||
fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
|
|
||||||
fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
|
|
||||||
fn vert_edges(&self,vert_id:VERT)->Cow<Vec<EDGE>>;
|
|
||||||
fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
|
|
||||||
}
|
|
||||||
struct FaceRefs{
|
|
||||||
edges:Vec<DirectedEdgeId>,
|
|
||||||
//verts:Vec<VertId>,
|
|
||||||
}
|
|
||||||
struct EdgeRefs{
|
|
||||||
faces:[FaceId;2],//left, right
|
|
||||||
verts:[VertId;2],//bottom, top
|
|
||||||
}
|
|
||||||
struct VertRefs{
|
|
||||||
faces:Vec<FaceId>,
|
|
||||||
edges:Vec<DirectedEdgeId>,
|
|
||||||
}
|
|
||||||
pub struct PhysicsMesh{
|
|
||||||
faces:Vec<Face>,
|
|
||||||
verts:Vec<Vert>,
|
|
||||||
face_topology:Vec<FaceRefs>,
|
|
||||||
edge_topology:Vec<EdgeRefs>,
|
|
||||||
vert_topology:Vec<VertRefs>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Default,Clone)]
|
|
||||||
struct VertRefGuy{
|
|
||||||
edges:std::collections::HashSet<DirectedEdgeId>,
|
|
||||||
faces:std::collections::HashSet<FaceId>,
|
|
||||||
}
|
|
||||||
#[derive(Clone,Hash,Eq,PartialEq)]
|
|
||||||
struct EdgeRefVerts([VertId;2]);
|
|
||||||
impl EdgeRefVerts{
|
|
||||||
fn new(v0:VertId,v1:VertId)->(Self,bool){
|
|
||||||
(if v0.0<v1.0{
|
|
||||||
Self([v0,v1])
|
|
||||||
}else{
|
|
||||||
Self([v1,v0])
|
|
||||||
},v0.0<v1.0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct EdgeRefFaces([FaceId;2]);
|
|
||||||
impl EdgeRefFaces{
|
|
||||||
fn new()->Self{
|
|
||||||
Self([FaceId(0);2])
|
|
||||||
}
|
|
||||||
fn push(&mut self,i:usize,face_id:FaceId){
|
|
||||||
self.0[i]=face_id;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct FaceRefEdges(Vec<DirectedEdgeId>);
|
|
||||||
#[derive(Default)]
|
|
||||||
struct EdgePool{
|
|
||||||
edge_guys:Vec<(EdgeRefVerts,EdgeRefFaces)>,
|
|
||||||
edge_id_from_guy:std::collections::HashMap<EdgeRefVerts,usize>,
|
|
||||||
}
|
|
||||||
impl EdgePool{
|
|
||||||
fn push(&mut self,edge_ref_verts:EdgeRefVerts)->(&mut EdgeRefFaces,EdgeId){
|
|
||||||
let edge_id=if let Some(&edge_id)=self.edge_id_from_guy.get(&edge_ref_verts){
|
|
||||||
edge_id
|
|
||||||
}else{
|
|
||||||
let edge_id=self.edge_guys.len();
|
|
||||||
self.edge_guys.push((edge_ref_verts.clone(),EdgeRefFaces::new()));
|
|
||||||
self.edge_id_from_guy.insert(edge_ref_verts,edge_id);
|
|
||||||
edge_id
|
|
||||||
};
|
|
||||||
(&mut unsafe{self.edge_guys.get_unchecked_mut(edge_id)}.1,EdgeId(edge_id))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl From<&crate::model::IndexedModel> for PhysicsMesh{
|
|
||||||
fn from(indexed_model:&crate::model::IndexedModel)->Self{
|
|
||||||
assert!(indexed_model.unique_pos.len()!=0,"Mesh cannot have 0 vertices");
|
|
||||||
let verts=indexed_model.unique_pos.iter().map(|v|Vert(v.clone())).collect();
|
|
||||||
let mut vert_ref_guys=vec![VertRefGuy::default();indexed_model.unique_pos.len()];
|
|
||||||
let mut edge_pool=EdgePool::default();
|
|
||||||
let mut face_i=0;
|
|
||||||
let mut faces=Vec::new();
|
|
||||||
let mut face_ref_guys=Vec::new();
|
|
||||||
for group in indexed_model.groups.iter(){for poly in group.polys.iter(){
|
|
||||||
let face_id=FaceId(face_i);
|
|
||||||
//one face per poly
|
|
||||||
let mut normal=Planar64Vec3::ZERO;
|
|
||||||
let len=poly.vertices.len();
|
|
||||||
let face_edges=poly.vertices.iter().enumerate().map(|(i,&vert_id)|{
|
|
||||||
let vert0_id=indexed_model.unique_vertices[vert_id as usize].pos as usize;
|
|
||||||
let vert1_id=indexed_model.unique_vertices[poly.vertices[(i+1)%len] as usize].pos as usize;
|
|
||||||
//https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal (Newell's Method)
|
|
||||||
let v0=indexed_model.unique_pos[vert0_id];
|
|
||||||
let v1=indexed_model.unique_pos[vert1_id];
|
|
||||||
normal+=Planar64Vec3::new(
|
|
||||||
(v0.y()-v1.y())*(v0.z()+v1.z()),
|
|
||||||
(v0.z()-v1.z())*(v0.x()+v1.x()),
|
|
||||||
(v0.x()-v1.x())*(v0.y()+v1.y()),
|
|
||||||
);
|
|
||||||
//get/create edge and push face into it
|
|
||||||
let (edge_ref_verts,is_sorted)=EdgeRefVerts::new(VertId(vert0_id),VertId(vert1_id));
|
|
||||||
let (edge_ref_faces,edge_id)=edge_pool.push(edge_ref_verts);
|
|
||||||
//polygon vertices as assumed to be listed clockwise
|
|
||||||
//populate the edge face on the left or right depending on how the edge vertices got sorted
|
|
||||||
edge_ref_faces.push(!is_sorted as usize,face_id);
|
|
||||||
//index edges & face into vertices
|
|
||||||
{
|
|
||||||
let vert_ref_guy=unsafe{vert_ref_guys.get_unchecked_mut(vert0_id)};
|
|
||||||
vert_ref_guy.edges.insert(edge_id.as_directed(is_sorted));
|
|
||||||
vert_ref_guy.faces.insert(face_id);
|
|
||||||
unsafe{vert_ref_guys.get_unchecked_mut(vert1_id)}.edges.insert(edge_id.as_directed(!is_sorted));
|
|
||||||
}
|
|
||||||
//return directed_edge_id
|
|
||||||
edge_id.as_directed(is_sorted)
|
|
||||||
}).collect();
|
|
||||||
//choose precision loss randomly idk
|
|
||||||
normal=normal/len as i64;
|
|
||||||
let mut dot=Planar64::ZERO;
|
|
||||||
for &v in poly.vertices.iter(){
|
|
||||||
dot+=normal.dot(indexed_model.unique_pos[indexed_model.unique_vertices[v as usize].pos as usize]);
|
|
||||||
}
|
|
||||||
faces.push(Face{normal,dot:dot/len as i64});
|
|
||||||
face_ref_guys.push(FaceRefEdges(face_edges));
|
|
||||||
face_i+=1;
|
|
||||||
}}
|
|
||||||
//conceivably faces, edges, and vertices exist now
|
|
||||||
Self{
|
|
||||||
faces,
|
|
||||||
verts,
|
|
||||||
face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
|
|
||||||
FaceRefs{edges:face_ref_guy.0}
|
|
||||||
}).collect(),
|
|
||||||
edge_topology:edge_pool.edge_guys.into_iter().map(|(edge_ref_verts,edge_ref_faces)|
|
|
||||||
EdgeRefs{faces:edge_ref_faces.0,verts:edge_ref_verts.0}
|
|
||||||
).collect(),
|
|
||||||
vert_topology:vert_ref_guys.into_iter().map(|vert_ref_guy|
|
|
||||||
VertRefs{
|
|
||||||
edges:vert_ref_guy.edges.into_iter().collect(),
|
|
||||||
faces:vert_ref_guy.faces.into_iter().collect(),
|
|
||||||
}
|
|
||||||
).collect(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PhysicsMesh{
|
|
||||||
pub fn verts<'a>(&'a self)->impl Iterator<Item=Planar64Vec3>+'a{
|
|
||||||
self.verts.iter().map(|Vert(pos)|*pos)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
|
|
||||||
fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
|
|
||||||
(self.faces[face_id.0].normal,self.faces[face_id.0].dot)
|
|
||||||
}
|
|
||||||
//ideally I never calculate the vertex position, but I have to for the graphical meshes...
|
|
||||||
fn vert(&self,vert_id:VertId)->Planar64Vec3{
|
|
||||||
self.verts[vert_id.0].0
|
|
||||||
}
|
|
||||||
fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
|
|
||||||
Cow::Borrowed(&self.face_topology[face_id.0].edges)
|
|
||||||
}
|
|
||||||
fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
|
|
||||||
Cow::Borrowed(&self.edge_topology[edge_id.0].faces)
|
|
||||||
}
|
|
||||||
fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
|
|
||||||
Cow::Borrowed(&self.edge_topology[edge_id.0].verts)
|
|
||||||
}
|
|
||||||
fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
|
|
||||||
Cow::Borrowed(&self.vert_topology[vert_id.0].edges)
|
|
||||||
}
|
|
||||||
fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
|
|
||||||
Cow::Borrowed(&self.vert_topology[vert_id.0].faces)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct TransformedMesh<'a>{
|
|
||||||
mesh:&'a PhysicsMesh,
|
|
||||||
transform:&'a integer::Planar64Affine3,
|
|
||||||
normal_transform:&'a integer::Planar64Mat3,
|
|
||||||
transform_det:Planar64,
|
|
||||||
}
|
|
||||||
impl TransformedMesh<'_>{
|
|
||||||
pub fn new<'a>(
|
|
||||||
mesh:&'a PhysicsMesh,
|
|
||||||
transform:&'a integer::Planar64Affine3,
|
|
||||||
normal_transform:&'a integer::Planar64Mat3,
|
|
||||||
transform_det:Planar64,
|
|
||||||
)->TransformedMesh<'a>{
|
|
||||||
TransformedMesh{
|
|
||||||
mesh,
|
|
||||||
transform,
|
|
||||||
normal_transform,
|
|
||||||
transform_det,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn farthest_vert(&self,dir:Planar64Vec3)->VertId{
|
|
||||||
let mut best_dot=Planar64::MIN;
|
|
||||||
let mut best_vert=VertId(0);
|
|
||||||
for (i,vert) in self.mesh.verts.iter().enumerate(){
|
|
||||||
let p=self.transform.transform_point3(vert.0);
|
|
||||||
let d=dir.dot(p);
|
|
||||||
if best_dot<d{
|
|
||||||
best_dot=d;
|
|
||||||
best_vert=VertId(i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
best_vert
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl MeshQuery<FaceId,DirectedEdgeId,VertId> for TransformedMesh<'_>{
|
|
||||||
fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
|
|
||||||
let (n,d)=self.mesh.face_nd(face_id);
|
|
||||||
let transformed_n=*self.normal_transform*n;
|
|
||||||
let transformed_d=d+transformed_n.dot(self.transform.translation)/self.transform_det;
|
|
||||||
(transformed_n/self.transform_det,transformed_d)
|
|
||||||
}
|
|
||||||
fn vert(&self,vert_id:VertId)->Planar64Vec3{
|
|
||||||
self.transform.transform_point3(self.mesh.vert(vert_id))
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
|
|
||||||
self.mesh.face_edges(face_id)
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
|
|
||||||
self.mesh.edge_faces(edge_id)
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
|
|
||||||
self.mesh.edge_verts(edge_id)
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
|
|
||||||
self.mesh.vert_edges(vert_id)
|
|
||||||
}
|
|
||||||
#[inline]
|
|
||||||
fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
|
|
||||||
self.mesh.vert_faces(vert_id)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
|
|
||||||
//(face,vertex)
|
|
||||||
//(edge,edge)
|
|
||||||
//(vertex,face)
|
|
||||||
#[derive(Clone,Copy)]
|
|
||||||
pub enum MinkowskiVert{
|
|
||||||
VertVert(VertId,VertId),
|
|
||||||
}
|
|
||||||
#[derive(Clone,Copy)]
|
|
||||||
pub enum MinkowskiEdge{
|
|
||||||
VertEdge(VertId,EdgeId),
|
|
||||||
EdgeVert(EdgeId,VertId),
|
|
||||||
//EdgeEdge when edges are parallel
|
|
||||||
}
|
|
||||||
impl UndirectedEdge for MinkowskiEdge{
|
|
||||||
type DirectedEdge=MinkowskiDirectedEdge;
|
|
||||||
fn as_directed(&self,parity:bool)->Self::DirectedEdge{
|
|
||||||
match self{
|
|
||||||
MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(*v0,e1.as_directed(parity)),
|
|
||||||
MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),*v1),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone,Copy)]
|
|
||||||
pub enum MinkowskiDirectedEdge{
|
|
||||||
VertEdge(VertId,DirectedEdgeId),
|
|
||||||
EdgeVert(DirectedEdgeId,VertId),
|
|
||||||
//EdgeEdge when edges are parallel
|
|
||||||
}
|
|
||||||
impl DirectedEdge for MinkowskiDirectedEdge{
|
|
||||||
type UndirectedEdge=MinkowskiEdge;
|
|
||||||
fn as_undirected(&self)->Self::UndirectedEdge{
|
|
||||||
match self{
|
|
||||||
MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
|
|
||||||
MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn parity(&self)->bool{
|
|
||||||
match self{
|
|
||||||
MinkowskiDirectedEdge::VertEdge(_,e)
|
|
||||||
|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
|
|
||||||
pub enum MinkowskiFace{
|
|
||||||
VertFace(VertId,FaceId),
|
|
||||||
EdgeEdge(EdgeId,EdgeId,bool),
|
|
||||||
FaceVert(FaceId,VertId),
|
|
||||||
//EdgeFace
|
|
||||||
//FaceEdge
|
|
||||||
//FaceFace
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct MinkowskiMesh<'a>{
|
|
||||||
mesh0:&'a TransformedMesh<'a>,
|
|
||||||
mesh1:&'a TransformedMesh<'a>,
|
|
||||||
}
|
|
||||||
|
|
||||||
//infinity fev algorithm state transition
|
|
||||||
enum Transition{
|
|
||||||
Done,//found closest vert, no edges are better
|
|
||||||
Vert(MinkowskiVert),//transition to vert
|
|
||||||
}
|
|
||||||
enum EV{
|
|
||||||
Vert(MinkowskiVert),
|
|
||||||
Edge(MinkowskiEdge),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl MinkowskiMesh<'_>{
|
|
||||||
pub fn minkowski_sum<'a>(mesh0:&'a TransformedMesh,mesh1:&'a TransformedMesh)->MinkowskiMesh<'a>{
|
|
||||||
MinkowskiMesh{
|
|
||||||
mesh0,
|
|
||||||
mesh1,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
|
|
||||||
MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
|
|
||||||
}
|
|
||||||
fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
|
|
||||||
let mut best_transition=Transition::Done;
|
|
||||||
for &directed_edge_id in self.vert_edges(vert_id).iter(){
|
|
||||||
let edge_n=self.directed_edge_n(directed_edge_id);
|
|
||||||
//is boundary uncrossable by a crawl from infinity
|
|
||||||
let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
|
|
||||||
//select opposite vertex
|
|
||||||
let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
|
|
||||||
//test if it's closer
|
|
||||||
let diff=point-self.vert(test_vert_id);
|
|
||||||
if zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
|
|
||||||
let distance_squared=diff.dot(diff);
|
|
||||||
if distance_squared<*best_distance_squared{
|
|
||||||
best_transition=Transition::Vert(test_vert_id);
|
|
||||||
*best_distance_squared=distance_squared;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
best_transition
|
|
||||||
}
|
|
||||||
fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
|
|
||||||
let mut best_transition=EV::Vert(vert_id);
|
|
||||||
let diff=point-self.vert(vert_id);
|
|
||||||
for &directed_edge_id in self.vert_edges(vert_id).iter(){
|
|
||||||
let edge_n=self.directed_edge_n(directed_edge_id);
|
|
||||||
//is boundary uncrossable by a crawl from infinity
|
|
||||||
//check if time of collision is outside Time::MIN..Time::MAX
|
|
||||||
let d=edge_n.dot(diff);
|
|
||||||
if zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
|
|
||||||
//test the edge
|
|
||||||
let edge_nn=edge_n.dot(edge_n);
|
|
||||||
if Planar64::ZERO<=d&&d<=edge_nn{
|
|
||||||
let distance_squared={
|
|
||||||
let c=diff.cross(edge_n);
|
|
||||||
c.dot(c)/edge_nn
|
|
||||||
};
|
|
||||||
if distance_squared<=*best_distance_squared{
|
|
||||||
best_transition=EV::Edge(directed_edge_id.as_undirected());
|
|
||||||
*best_distance_squared=distance_squared;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
best_transition
|
|
||||||
}
|
|
||||||
fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
|
|
||||||
let mut best_distance_squared={
|
|
||||||
let diff=point-self.vert(vert_id);
|
|
||||||
diff.dot(diff)
|
|
||||||
};
|
|
||||||
loop{
|
|
||||||
match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
|
|
||||||
Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
|
|
||||||
Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
|
|
||||||
fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>{
|
|
||||||
//start on any vertex
|
|
||||||
//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
|
|
||||||
//cross edge-face boundary if it's uncrossable
|
|
||||||
match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
|
|
||||||
//if a vert is returned, it is the closest point to the infinity point
|
|
||||||
EV::Vert(vert_id)=>FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Vert(vert_id),
|
|
||||||
EV::Edge(edge_id)=>{
|
|
||||||
//cross to face if the boundary is not crossable and we are on the wrong side
|
|
||||||
let edge_n=self.edge_n(edge_id);
|
|
||||||
// point is multiplied by two because vert_sum sums two vertices.
|
|
||||||
let delta_pos=point*2-{
|
|
||||||
let &[v0,v1]=self.edge_verts(edge_id).borrow();
|
|
||||||
self.vert(v0)+self.vert(v1)
|
|
||||||
};
|
|
||||||
for (i,&face_id) in self.edge_faces(edge_id).iter().enumerate(){
|
|
||||||
let face_n=self.face_nd(face_id).0;
|
|
||||||
//edge-face boundary nd, n facing out of the face towards the edge
|
|
||||||
let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
|
|
||||||
let boundary_d=boundary_n.dot(delta_pos);
|
|
||||||
//check if time of collision is outside Time::MIN..Time::MAX
|
|
||||||
//infinity_dir can always be treated as a velocity
|
|
||||||
if (boundary_d)<=Planar64::ZERO&&zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
|
|
||||||
//both faces cannot pass this condition, return early if one does.
|
|
||||||
return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Edge(edge_id)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn closest_fev_not_inside(&self,mut infinity_body:crate::physics::Body)->Option<FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>>{
|
|
||||||
infinity_body.infinity_dir().map_or(None,|dir|{
|
|
||||||
let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
|
|
||||||
//a line is simpler to solve than a parabola
|
|
||||||
infinity_body.velocity=dir;
|
|
||||||
infinity_body.acceleration=Planar64Vec3::ZERO;
|
|
||||||
//crawl in from negative infinity along a tangent line to get the closest fev
|
|
||||||
match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN,infinity_body.time){
|
|
||||||
crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
|
|
||||||
crate::face_crawler::CrawlResult::Hit(_,_)=>None,
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
|
|
||||||
self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
|
|
||||||
//continue forwards along the body parabola
|
|
||||||
match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
|
|
||||||
crate::face_crawler::CrawlResult::Miss(_)=>None,
|
|
||||||
crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
|
|
||||||
//create an extrapolated body at time_limit
|
|
||||||
let infinity_body=crate::physics::Body::new(
|
|
||||||
relative_body.extrapolated_position(time_limit),
|
|
||||||
-relative_body.extrapolated_velocity(time_limit),
|
|
||||||
relative_body.acceleration,
|
|
||||||
-time_limit,
|
|
||||||
);
|
|
||||||
self.closest_fev_not_inside(infinity_body).map_or(None,|fev|{
|
|
||||||
//continue backwards along the body parabola
|
|
||||||
match crate::face_crawler::crawl_fev(fev,self,&-relative_body.clone(),-time_limit,-relative_body.time){
|
|
||||||
crate::face_crawler::CrawlResult::Miss(_)=>None,
|
|
||||||
crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,-time)),//no need to test -time<time_limit because of the first step
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,integer::Time)>{
|
|
||||||
//no algorithm needed, there is only one state and two cases (Edge,None)
|
|
||||||
//determine when it passes an edge ("sliding off" case)
|
|
||||||
let mut best_time=time_limit;
|
|
||||||
let mut best_edge=None;
|
|
||||||
let face_n=self.face_nd(contact_face_id).0;
|
|
||||||
for &directed_edge_id in self.face_edges(contact_face_id).iter(){
|
|
||||||
let edge_n=self.directed_edge_n(directed_edge_id);
|
|
||||||
//f x e points in
|
|
||||||
let n=face_n.cross(edge_n);
|
|
||||||
let verts=self.edge_verts(directed_edge_id.as_undirected());
|
|
||||||
let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
|
|
||||||
//WARNING! d outside of *2
|
|
||||||
for t in zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
|
|
||||||
let t=relative_body.time+integer::Time::from(t);
|
|
||||||
if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
|
|
||||||
best_time=t;
|
|
||||||
best_edge=Some(directed_edge_id);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
best_edge.map(|e|(e.as_undirected(),best_time))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
|
|
||||||
fn face_nd(&self,face_id:MinkowskiFace)->(Planar64Vec3,Planar64){
|
|
||||||
match face_id{
|
|
||||||
MinkowskiFace::VertFace(v0,f1)=>{
|
|
||||||
let (n,d)=self.mesh1.face_nd(f1);
|
|
||||||
(-n,d-n.dot(self.mesh0.vert(v0)))
|
|
||||||
},
|
|
||||||
MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
|
|
||||||
let edge0_n=self.mesh0.edge_n(e0);
|
|
||||||
let edge1_n=self.mesh1.edge_n(e1);
|
|
||||||
let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).borrow();
|
|
||||||
let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).borrow();
|
|
||||||
let n=edge0_n.cross(edge1_n);
|
|
||||||
let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
|
|
||||||
let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
|
|
||||||
(n*(parity as i64*4-2),(e0d-e1d)*(parity as i64*2-1))
|
|
||||||
},
|
|
||||||
MinkowskiFace::FaceVert(f0,v1)=>{
|
|
||||||
let (n,d)=self.mesh0.face_nd(f0);
|
|
||||||
(n,d-n.dot(self.mesh1.vert(v1)))
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
|
|
||||||
match vert_id{
|
|
||||||
MinkowskiVert::VertVert(v0,v1)=>{
|
|
||||||
self.mesh0.vert(v0)-self.mesh1.vert(v1)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn face_edges(&self,face_id:MinkowskiFace)->Cow<Vec<MinkowskiDirectedEdge>>{
|
|
||||||
match face_id{
|
|
||||||
MinkowskiFace::VertFace(v0,f1)=>{
|
|
||||||
Cow::Owned(self.mesh1.face_edges(f1).iter().map(|&edge_id1|{
|
|
||||||
MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
|
|
||||||
}).collect())
|
|
||||||
},
|
|
||||||
MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
|
|
||||||
let e0v=self.mesh0.edge_verts(e0);
|
|
||||||
let e1v=self.mesh1.edge_verts(e1);
|
|
||||||
//could sort this if ordered edges are needed
|
|
||||||
//probably just need to reverse this list according to parity
|
|
||||||
Cow::Owned(vec![
|
|
||||||
MinkowskiDirectedEdge::VertEdge(e0v[0],e1.as_directed(parity)),
|
|
||||||
MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v[0]),
|
|
||||||
MinkowskiDirectedEdge::VertEdge(e0v[1],e1.as_directed(!parity)),
|
|
||||||
MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v[1]),
|
|
||||||
])
|
|
||||||
},
|
|
||||||
MinkowskiFace::FaceVert(f0,v1)=>{
|
|
||||||
Cow::Owned(self.mesh0.face_edges(f0).iter().map(|&edge_id0|{
|
|
||||||
MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
|
|
||||||
}).collect())
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn edge_faces(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiFace;2]>{
|
|
||||||
match edge_id{
|
|
||||||
MinkowskiEdge::VertEdge(v0,e1)=>{
|
|
||||||
//faces are listed backwards from the minkowski mesh
|
|
||||||
let v0e=self.mesh0.vert_edges(v0);
|
|
||||||
let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).borrow();
|
|
||||||
Cow::Owned([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
|
|
||||||
let mut best_edge=None;
|
|
||||||
let mut best_d=Planar64::ZERO;
|
|
||||||
let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
|
|
||||||
let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
|
|
||||||
for &directed_edge_id0 in v0e.iter(){
|
|
||||||
let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
|
|
||||||
//must be behind other face.
|
|
||||||
let d=edge_face1_n.dot(edge0_n);
|
|
||||||
if d<Planar64::ZERO{
|
|
||||||
let edge0_nn=edge0_n.dot(edge0_n);
|
|
||||||
//divide by zero???
|
|
||||||
let dd=d*d/(edge_face1_nn*edge0_nn);
|
|
||||||
if best_d<dd{
|
|
||||||
best_d=dd;
|
|
||||||
best_edge=Some(directed_edge_id0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
best_edge.map_or(
|
|
||||||
MinkowskiFace::VertFace(v0,edge_face_id1),
|
|
||||||
|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
|
|
||||||
)
|
|
||||||
}))
|
|
||||||
},
|
|
||||||
MinkowskiEdge::EdgeVert(e0,v1)=>{
|
|
||||||
//tracking index with an external variable because .enumerate() is not available
|
|
||||||
let v1e=self.mesh1.vert_edges(v1);
|
|
||||||
let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).borrow();
|
|
||||||
Cow::Owned([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
|
|
||||||
let mut best_edge=None;
|
|
||||||
let mut best_d=Planar64::ZERO;
|
|
||||||
let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
|
|
||||||
let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
|
|
||||||
for &directed_edge_id1 in v1e.iter(){
|
|
||||||
let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
|
|
||||||
let d=edge_face0_n.dot(edge1_n);
|
|
||||||
if d<Planar64::ZERO{
|
|
||||||
let edge1_nn=edge1_n.dot(edge1_n);
|
|
||||||
let dd=d*d/(edge_face0_nn*edge1_nn);
|
|
||||||
if best_d<dd{
|
|
||||||
best_d=dd;
|
|
||||||
best_edge=Some(directed_edge_id1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
best_edge.map_or(
|
|
||||||
MinkowskiFace::FaceVert(edge_face_id0,v1),
|
|
||||||
|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
|
|
||||||
)
|
|
||||||
}))
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn edge_verts(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiVert;2]>{
|
|
||||||
match edge_id{
|
|
||||||
MinkowskiEdge::VertEdge(v0,e1)=>{
|
|
||||||
Cow::Owned(self.mesh1.edge_verts(e1).map(|vert_id1|{
|
|
||||||
MinkowskiVert::VertVert(v0,vert_id1)
|
|
||||||
}))
|
|
||||||
},
|
|
||||||
MinkowskiEdge::EdgeVert(e0,v1)=>{
|
|
||||||
Cow::Owned(self.mesh0.edge_verts(e0).map(|vert_id0|{
|
|
||||||
MinkowskiVert::VertVert(vert_id0,v1)
|
|
||||||
}))
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn vert_edges(&self,vert_id:MinkowskiVert)->Cow<Vec<MinkowskiDirectedEdge>>{
|
|
||||||
match vert_id{
|
|
||||||
MinkowskiVert::VertVert(v0,v1)=>{
|
|
||||||
let mut edges=Vec::new();
|
|
||||||
//detect shared volume when the other mesh is mirrored along a test edge dir
|
|
||||||
let v0f=self.mesh0.vert_faces(v0);
|
|
||||||
let v1f=self.mesh1.vert_faces(v1);
|
|
||||||
let v0f_n:Vec<Planar64Vec3>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
|
|
||||||
let v1f_n:Vec<Planar64Vec3>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
|
|
||||||
let the_len=v0f.len()+v1f.len();
|
|
||||||
for &directed_edge_id in self.mesh0.vert_edges(v0).iter(){
|
|
||||||
let n=self.mesh0.directed_edge_n(directed_edge_id);
|
|
||||||
let nn=n.dot(n);
|
|
||||||
//make a set of faces
|
|
||||||
let mut face_normals=Vec::with_capacity(the_len);
|
|
||||||
//add mesh0 faces as-is
|
|
||||||
face_normals.clone_from(&v0f_n);
|
|
||||||
for face_n in &v1f_n{
|
|
||||||
//add reflected mesh1 faces
|
|
||||||
face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
|
|
||||||
}
|
|
||||||
if is_empty_volume(face_normals){
|
|
||||||
edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for &directed_edge_id in self.mesh1.vert_edges(v1).iter(){
|
|
||||||
let n=self.mesh1.directed_edge_n(directed_edge_id);
|
|
||||||
let nn=n.dot(n);
|
|
||||||
let mut face_normals=Vec::with_capacity(the_len);
|
|
||||||
face_normals.clone_from(&v1f_n);
|
|
||||||
for face_n in &v0f_n{
|
|
||||||
face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
|
|
||||||
}
|
|
||||||
if is_empty_volume(face_normals){
|
|
||||||
edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Cow::Owned(edges)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<Vec<MinkowskiFace>>{
|
|
||||||
unimplemented!()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn is_empty_volume(normals:Vec<Planar64Vec3>)->bool{
|
|
||||||
let len=normals.len();
|
|
||||||
for i in 0..len-1{
|
|
||||||
for j in i+1..len{
|
|
||||||
let n=normals[i].cross(normals[j]);
|
|
||||||
let mut d_comp=None;
|
|
||||||
for k in 0..len{
|
|
||||||
if k!=i&&k!=j{
|
|
||||||
let d=n.dot(normals[k]);
|
|
||||||
if let Some(comp)=&d_comp{
|
|
||||||
if *comp*d<Planar64::ZERO{
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
d_comp=Some(d);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_is_empty_volume(){
|
|
||||||
assert!(!is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z].to_vec()));
|
|
||||||
assert!(is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z,Planar64Vec3::NEG_X].to_vec()));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn build_me_a_cube(){
|
|
||||||
let unit_cube=crate::primitives::unit_cube();
|
|
||||||
let mesh=PhysicsMesh::from(&unit_cube);
|
|
||||||
//println!("mesh={:?}",mesh);
|
|
||||||
}
|
|
1877
src/physics.rs
1877
src/physics.rs
File diff suppressed because it is too large
Load Diff
@ -1,165 +0,0 @@
|
|||||||
use crate::physics::{MouseState,PhysicsInputInstruction};
|
|
||||||
use strafesnet_common::integer::Time;
|
|
||||||
use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
|
|
||||||
use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub enum InputInstruction {
|
|
||||||
MoveMouse(glam::IVec2),
|
|
||||||
MoveRight(bool),
|
|
||||||
MoveUp(bool),
|
|
||||||
MoveBack(bool),
|
|
||||||
MoveLeft(bool),
|
|
||||||
MoveDown(bool),
|
|
||||||
MoveForward(bool),
|
|
||||||
Jump(bool),
|
|
||||||
Zoom(bool),
|
|
||||||
Reset,
|
|
||||||
}
|
|
||||||
pub enum Instruction{
|
|
||||||
Input(InputInstruction),
|
|
||||||
Render,
|
|
||||||
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
|
|
||||||
GenerateModels(crate::model::IndexedModelInstances),
|
|
||||||
ClearModels,
|
|
||||||
//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>>{
|
|
||||||
let mut mouse_blocking=true;
|
|
||||||
let mut last_mouse_time=physics.next_mouse.time;
|
|
||||||
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>|{
|
|
||||||
if if let Some(phys_input)=match &ins.instruction{
|
|
||||||
Instruction::Input(input_instruction)=>match input_instruction{
|
|
||||||
&InputInstruction::MoveMouse(m)=>{
|
|
||||||
if mouse_blocking{
|
|
||||||
//tell the game state which is living in the past about its future
|
|
||||||
timeline.push_front(TimedInstruction{
|
|
||||||
time:last_mouse_time,
|
|
||||||
instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:m}),
|
|
||||||
});
|
|
||||||
}else{
|
|
||||||
//mouse has just started moving again after being still for longer than 10ms.
|
|
||||||
//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
|
|
||||||
timeline.push_front(TimedInstruction{
|
|
||||||
time:last_mouse_time,
|
|
||||||
instruction:PhysicsInputInstruction::ReplaceMouse(
|
|
||||||
MouseState{time:last_mouse_time,pos:physics.next_mouse.pos},
|
|
||||||
MouseState{time:ins.time,pos:m}
|
|
||||||
),
|
|
||||||
});
|
|
||||||
//delay physics execution until we have an interpolation target
|
|
||||||
mouse_blocking=true;
|
|
||||||
}
|
|
||||||
last_mouse_time=ins.time;
|
|
||||||
None
|
|
||||||
},
|
|
||||||
&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
|
|
||||||
&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
|
|
||||||
&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
|
|
||||||
&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
|
|
||||||
&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
|
|
||||||
&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
|
|
||||||
&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
|
|
||||||
&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
|
|
||||||
InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
|
|
||||||
},
|
|
||||||
Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
|
|
||||||
Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
|
|
||||||
Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
|
|
||||||
Instruction::Render=>Some(PhysicsInputInstruction::Idle),
|
|
||||||
}{
|
|
||||||
//non-mouse event
|
|
||||||
timeline.push_back(TimedInstruction{
|
|
||||||
time:ins.time,
|
|
||||||
instruction:phys_input,
|
|
||||||
});
|
|
||||||
|
|
||||||
if mouse_blocking{
|
|
||||||
//assume the mouse has stopped moving after 10ms.
|
|
||||||
//shitty mice are 125Hz which is 8ms so this should cover that.
|
|
||||||
//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
|
|
||||||
//so mouse events are probably not handled separately from drawing and fire right before it :(
|
|
||||||
if Time::from_millis(10)<ins.time-physics.next_mouse.time{
|
|
||||||
//push an event to extrapolate no movement from
|
|
||||||
timeline.push_front(TimedInstruction{
|
|
||||||
time:last_mouse_time,
|
|
||||||
instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}),
|
|
||||||
});
|
|
||||||
last_mouse_time=ins.time;
|
|
||||||
//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
|
|
||||||
mouse_blocking=false;
|
|
||||||
true
|
|
||||||
}else{
|
|
||||||
false
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
//keep this up to date so that it can be used as a known-timestamp
|
|
||||||
//that the mouse was not moving when the mouse starts moving again
|
|
||||||
last_mouse_time=ins.time;
|
|
||||||
true
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
//mouse event
|
|
||||||
true
|
|
||||||
}{
|
|
||||||
//empty queue
|
|
||||||
while let Some(instruction)=timeline.pop_front(){
|
|
||||||
physics.run(instruction.time);
|
|
||||||
physics.process_instruction(TimedInstruction{
|
|
||||||
time:instruction.time,
|
|
||||||
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{
|
|
||||||
Instruction::Render=>{
|
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
|
|
||||||
},
|
|
||||||
Instruction::Resize(size,user_settings)=>{
|
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
|
|
||||||
},
|
|
||||||
Instruction::GenerateModels(indexed_model_instances)=>{
|
|
||||||
physics.generate_models(&indexed_model_instances);
|
|
||||||
physics.spawn(indexed_model_instances.spawn_point);
|
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
|
|
||||||
},
|
|
||||||
Instruction::ClearModels=>{
|
|
||||||
physics.clear();
|
|
||||||
graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
|
|
||||||
},
|
|
||||||
_=>(),
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
@ -1,5 +1,5 @@
|
|||||||
use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
|
use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
|
||||||
use strafesnet_common::integer::Planar64Vec3;
|
use crate::integer::Planar64Vec3;
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub enum Primitives{
|
pub enum Primitives{
|
||||||
@ -126,21 +126,17 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
|
|||||||
Planar64Vec3::int( 0,-1, 0),//CornerWedge::Bottom
|
Planar64Vec3::int( 0,-1, 0),//CornerWedge::Bottom
|
||||||
Planar64Vec3::int( 0, 0,-1),//CornerWedge::Front
|
Planar64Vec3::int( 0, 0,-1),//CornerWedge::Front
|
||||||
];
|
];
|
||||||
|
//HashMap fits this use case perfectly but feels like using a sledgehammer to drive a nail
|
||||||
pub fn unit_sphere()->crate::model::IndexedModel{
|
pub fn unit_sphere()->crate::model::IndexedModel{
|
||||||
unit_cube()
|
let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),Color4::ONE).remove(0);
|
||||||
}
|
for pos in indexed_model.unique_pos.iter_mut(){
|
||||||
#[derive(Default)]
|
*pos=*pos/2;
|
||||||
pub struct CubeFaceDescription([Option<FaceDescription>;6]);
|
|
||||||
impl CubeFaceDescription{
|
|
||||||
pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
|
|
||||||
self.0[index as usize]=Some(value);
|
|
||||||
}
|
|
||||||
pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,6>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
|
|
||||||
self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
|
|
||||||
}
|
}
|
||||||
|
indexed_model
|
||||||
}
|
}
|
||||||
|
pub type CubeFaceDescription=std::collections::HashMap::<CubeFace,FaceDescription>;
|
||||||
pub fn unit_cube()->crate::model::IndexedModel{
|
pub fn unit_cube()->crate::model::IndexedModel{
|
||||||
let mut t=CubeFaceDescription::default();
|
let mut t=CubeFaceDescription::new();
|
||||||
t.insert(CubeFace::Right,FaceDescription::default());
|
t.insert(CubeFace::Right,FaceDescription::default());
|
||||||
t.insert(CubeFace::Top,FaceDescription::default());
|
t.insert(CubeFace::Top,FaceDescription::default());
|
||||||
t.insert(CubeFace::Back,FaceDescription::default());
|
t.insert(CubeFace::Back,FaceDescription::default());
|
||||||
@ -149,21 +145,17 @@ pub fn unit_cube()->crate::model::IndexedModel{
|
|||||||
t.insert(CubeFace::Front,FaceDescription::default());
|
t.insert(CubeFace::Front,FaceDescription::default());
|
||||||
generate_partial_unit_cube(t)
|
generate_partial_unit_cube(t)
|
||||||
}
|
}
|
||||||
|
const TEAPOT_TRANSFORM:crate::integer::Planar64Mat3=crate::integer::Planar64Mat3::int_from_cols_array([0,1,0, -1,0,0, 0,0,1]);
|
||||||
pub fn unit_cylinder()->crate::model::IndexedModel{
|
pub fn unit_cylinder()->crate::model::IndexedModel{
|
||||||
unit_cube()
|
let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),Color4::ONE).remove(0);
|
||||||
}
|
for pos in indexed_model.unique_pos.iter_mut(){
|
||||||
#[derive(Default)]
|
*pos=TEAPOT_TRANSFORM*(*pos)/10;
|
||||||
pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
|
|
||||||
impl WedgeFaceDescription{
|
|
||||||
pub fn insert(&mut self,index:WedgeFace,value:FaceDescription){
|
|
||||||
self.0[index as usize]=Some(value);
|
|
||||||
}
|
|
||||||
pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
|
|
||||||
self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
|
|
||||||
}
|
}
|
||||||
|
indexed_model
|
||||||
}
|
}
|
||||||
|
pub type WedgeFaceDescription=std::collections::HashMap::<WedgeFace,FaceDescription>;
|
||||||
pub fn unit_wedge()->crate::model::IndexedModel{
|
pub fn unit_wedge()->crate::model::IndexedModel{
|
||||||
let mut t=WedgeFaceDescription::default();
|
let mut t=WedgeFaceDescription::new();
|
||||||
t.insert(WedgeFace::Right,FaceDescription::default());
|
t.insert(WedgeFace::Right,FaceDescription::default());
|
||||||
t.insert(WedgeFace::TopFront,FaceDescription::default());
|
t.insert(WedgeFace::TopFront,FaceDescription::default());
|
||||||
t.insert(WedgeFace::Back,FaceDescription::default());
|
t.insert(WedgeFace::Back,FaceDescription::default());
|
||||||
@ -171,18 +163,9 @@ pub fn unit_wedge()->crate::model::IndexedModel{
|
|||||||
t.insert(WedgeFace::Bottom,FaceDescription::default());
|
t.insert(WedgeFace::Bottom,FaceDescription::default());
|
||||||
generate_partial_unit_wedge(t)
|
generate_partial_unit_wedge(t)
|
||||||
}
|
}
|
||||||
#[derive(Default)]
|
pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,FaceDescription>;
|
||||||
pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
|
|
||||||
impl CornerWedgeFaceDescription{
|
|
||||||
pub fn insert(&mut self,index:CornerWedgeFace,value:FaceDescription){
|
|
||||||
self.0[index as usize]=Some(value);
|
|
||||||
}
|
|
||||||
pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
|
|
||||||
self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn unit_cornerwedge()->crate::model::IndexedModel{
|
pub fn unit_cornerwedge()->crate::model::IndexedModel{
|
||||||
let mut t=CornerWedgeFaceDescription::default();
|
let mut t=CornerWedgeFaceDescription::new();
|
||||||
t.insert(CornerWedgeFace::Right,FaceDescription::default());
|
t.insert(CornerWedgeFace::Right,FaceDescription::default());
|
||||||
t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
|
t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
|
||||||
t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
|
t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
|
||||||
@ -206,6 +189,18 @@ impl std::default::Default for FaceDescription{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
impl FaceDescription{
|
||||||
|
pub fn new(texture:u32,transform:glam::Affine2,color:Color4)->Self{
|
||||||
|
Self{texture:Some(texture),transform,color}
|
||||||
|
}
|
||||||
|
pub fn from_texture(texture:u32)->Self{
|
||||||
|
Self{
|
||||||
|
texture:Some(texture),
|
||||||
|
transform:glam::Affine2::IDENTITY,
|
||||||
|
color:Color4::ONE,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
//TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
|
//TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
|
||||||
//implementation: put all roblox primitives into one model.groups <- this won't work but I forget why
|
//implementation: put all roblox primitives into one model.groups <- this won't work but I forget why
|
||||||
pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate::model::IndexedModel{
|
pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate::model::IndexedModel{
|
||||||
@ -217,7 +212,7 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
|
|||||||
let mut groups=Vec::new();
|
let mut groups=Vec::new();
|
||||||
let mut transforms=Vec::new();
|
let mut transforms=Vec::new();
|
||||||
//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
|
//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
|
||||||
for (face_id,face_description) in face_descriptions.pairs(){
|
for (face,face_description) in face_descriptions.into_iter(){
|
||||||
//assume that scanning short lists is faster than hashing.
|
//assume that scanning short lists is faster than hashing.
|
||||||
let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
|
let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
|
||||||
transform_index
|
transform_index
|
||||||
@ -238,6 +233,14 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
|
|||||||
generated_color.push(face_description.color);
|
generated_color.push(face_description.color);
|
||||||
color_index
|
color_index
|
||||||
} as u32;
|
} as u32;
|
||||||
|
let face_id=match face{
|
||||||
|
CubeFace::Right => 0,
|
||||||
|
CubeFace::Top => 1,
|
||||||
|
CubeFace::Back => 2,
|
||||||
|
CubeFace::Left => 3,
|
||||||
|
CubeFace::Bottom => 4,
|
||||||
|
CubeFace::Front => 5,
|
||||||
|
};
|
||||||
//always push normal
|
//always push normal
|
||||||
let normal_index=generated_normal.len() as u32;
|
let normal_index=generated_normal.len() as u32;
|
||||||
generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
|
generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
|
||||||
@ -324,7 +327,7 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
|
|||||||
let mut groups=Vec::new();
|
let mut groups=Vec::new();
|
||||||
let mut transforms=Vec::new();
|
let mut transforms=Vec::new();
|
||||||
//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
|
//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
|
||||||
for (face_id,face_description) in face_descriptions.pairs(){
|
for (face,face_description) in face_descriptions.into_iter(){
|
||||||
//assume that scanning short lists is faster than hashing.
|
//assume that scanning short lists is faster than hashing.
|
||||||
let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
|
let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
|
||||||
transform_index
|
transform_index
|
||||||
@ -345,6 +348,13 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
|
|||||||
generated_color.push(face_description.color);
|
generated_color.push(face_description.color);
|
||||||
color_index
|
color_index
|
||||||
} as u32;
|
} as u32;
|
||||||
|
let face_id=match face{
|
||||||
|
WedgeFace::Right => 0,
|
||||||
|
WedgeFace::TopFront => 1,
|
||||||
|
WedgeFace::Back => 2,
|
||||||
|
WedgeFace::Left => 3,
|
||||||
|
WedgeFace::Bottom => 4,
|
||||||
|
};
|
||||||
//always push normal
|
//always push normal
|
||||||
let normal_index=generated_normal.len() as u32;
|
let normal_index=generated_normal.len() as u32;
|
||||||
generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
|
generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
|
||||||
@ -429,7 +439,7 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
|
|||||||
let mut groups=Vec::new();
|
let mut groups=Vec::new();
|
||||||
let mut transforms=Vec::new();
|
let mut transforms=Vec::new();
|
||||||
//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
|
//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
|
||||||
for (face_id,face_description) in face_descriptions.pairs(){
|
for (face,face_description) in face_descriptions.into_iter(){
|
||||||
//assume that scanning short lists is faster than hashing.
|
//assume that scanning short lists is faster than hashing.
|
||||||
let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
|
let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
|
||||||
transform_index
|
transform_index
|
||||||
@ -450,6 +460,13 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
|
|||||||
generated_color.push(face_description.color);
|
generated_color.push(face_description.color);
|
||||||
color_index
|
color_index
|
||||||
} as u32;
|
} as u32;
|
||||||
|
let face_id=match face{
|
||||||
|
CornerWedgeFace::Right => 0,
|
||||||
|
CornerWedgeFace::TopBack => 1,
|
||||||
|
CornerWedgeFace::TopLeft => 2,
|
||||||
|
CornerWedgeFace::Bottom => 3,
|
||||||
|
CornerWedgeFace::Front => 4,
|
||||||
|
};
|
||||||
//always push normal
|
//always push normal
|
||||||
let normal_index=generated_normal.len() as u32;
|
let normal_index=generated_normal.len() as u32;
|
||||||
generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);
|
generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);
|
||||||
|
@ -1,14 +1,11 @@
|
|||||||
use strafesnet_common::integer::{Ratio64,Ratio64Vec2};
|
use crate::integer::{Ratio64,Ratio64Vec2};
|
||||||
#[derive(Clone)]
|
|
||||||
struct Ratio{
|
struct Ratio{
|
||||||
ratio:f64,
|
ratio:f64,
|
||||||
}
|
}
|
||||||
#[derive(Clone)]
|
|
||||||
enum DerivedFov{
|
enum DerivedFov{
|
||||||
FromScreenAspect,
|
FromScreenAspect,
|
||||||
FromAspect(Ratio),
|
FromAspect(Ratio),
|
||||||
}
|
}
|
||||||
#[derive(Clone)]
|
|
||||||
enum Fov{
|
enum Fov{
|
||||||
Exactly{x:f64,y:f64},
|
Exactly{x:f64,y:f64},
|
||||||
SpecifyXDeriveY{x:f64,y:DerivedFov},
|
SpecifyXDeriveY{x:f64,y:DerivedFov},
|
||||||
@ -19,11 +16,9 @@ impl Default for Fov{
|
|||||||
Fov::SpecifyYDeriveX{x:DerivedFov::FromScreenAspect,y:1.0}
|
Fov::SpecifyYDeriveX{x:DerivedFov::FromScreenAspect,y:1.0}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[derive(Clone)]
|
|
||||||
enum DerivedSensitivity{
|
enum DerivedSensitivity{
|
||||||
FromRatio(Ratio64),
|
FromRatio(Ratio64),
|
||||||
}
|
}
|
||||||
#[derive(Clone)]
|
|
||||||
enum Sensitivity{
|
enum Sensitivity{
|
||||||
Exactly{x:Ratio64,y:Ratio64},
|
Exactly{x:Ratio64,y:Ratio64},
|
||||||
SpecifyXDeriveY{x:Ratio64,y:DerivedSensitivity},
|
SpecifyXDeriveY{x:Ratio64,y:DerivedSensitivity},
|
||||||
@ -35,7 +30,7 @@ impl Default for Sensitivity{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Default,Clone)]
|
#[derive(Default)]
|
||||||
pub struct UserSettings{
|
pub struct UserSettings{
|
||||||
fov:Fov,
|
fov:Fov,
|
||||||
sensitivity:Sensitivity,
|
sensitivity:Sensitivity,
|
||||||
|
281
src/setup.rs
281
src/setup.rs
@ -1,281 +0,0 @@
|
|||||||
use crate::window::WindowInstruction;
|
|
||||||
use strafesnet_common::instruction::TimedInstruction;
|
|
||||||
use strafesnet_common::integer;
|
|
||||||
|
|
||||||
fn optional_features()->wgpu::Features{
|
|
||||||
wgpu::Features::TEXTURE_COMPRESSION_ASTC
|
|
||||||
|wgpu::Features::TEXTURE_COMPRESSION_ETC2
|
|
||||||
}
|
|
||||||
fn required_features()->wgpu::Features{
|
|
||||||
wgpu::Features::TEXTURE_COMPRESSION_BC
|
|
||||||
}
|
|
||||||
fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
|
|
||||||
wgpu::DownlevelCapabilities{
|
|
||||||
flags:wgpu::DownlevelFlags::empty(),
|
|
||||||
shader_model:wgpu::ShaderModel::Sm5,
|
|
||||||
..wgpu::DownlevelCapabilities::default()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn required_limits()->wgpu::Limits{
|
|
||||||
wgpu::Limits::default()
|
|
||||||
}
|
|
||||||
|
|
||||||
struct SetupContextPartial1{
|
|
||||||
backends:wgpu::Backends,
|
|
||||||
instance:wgpu::Instance,
|
|
||||||
}
|
|
||||||
fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
|
|
||||||
let mut builder = winit::window::WindowBuilder::new();
|
|
||||||
builder = builder.with_title(title);
|
|
||||||
#[cfg(windows_OFF)] // TODO
|
|
||||||
{
|
|
||||||
use winit::platform::windows::WindowBuilderExtWindows;
|
|
||||||
builder = builder.with_no_redirection_bitmap(true);
|
|
||||||
}
|
|
||||||
builder.build(event_loop)
|
|
||||||
}
|
|
||||||
fn create_instance()->SetupContextPartial1{
|
|
||||||
let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
|
|
||||||
let dx12_shader_compiler=wgpu::util::dx12_shader_compiler_from_env().unwrap_or_default();
|
|
||||||
SetupContextPartial1{
|
|
||||||
backends,
|
|
||||||
instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
|
|
||||||
backends,
|
|
||||||
dx12_shader_compiler,
|
|
||||||
..Default::default()
|
|
||||||
}),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl SetupContextPartial1{
|
|
||||||
fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
|
|
||||||
Ok(SetupContextPartial2{
|
|
||||||
backends:self.backends,
|
|
||||||
surface:self.instance.create_surface(window)?,
|
|
||||||
instance:self.instance,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct SetupContextPartial2<'a>{
|
|
||||||
backends:wgpu::Backends,
|
|
||||||
instance:wgpu::Instance,
|
|
||||||
surface:wgpu::Surface<'a>,
|
|
||||||
}
|
|
||||||
impl<'a> SetupContextPartial2<'a>{
|
|
||||||
fn pick_adapter(self)->SetupContextPartial3<'a>{
|
|
||||||
let adapter;
|
|
||||||
|
|
||||||
//TODO: prefer adapter that implements optional features
|
|
||||||
//let optional_features=optional_features();
|
|
||||||
let required_features=required_features();
|
|
||||||
|
|
||||||
//no helper function smh gotta write it myself
|
|
||||||
let adapters=self.instance.enumerate_adapters(self.backends);
|
|
||||||
|
|
||||||
let mut chosen_adapter=None;
|
|
||||||
let mut chosen_adapter_score=0;
|
|
||||||
for adapter in adapters {
|
|
||||||
if !adapter.is_surface_supported(&self.surface) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
let score=match adapter.get_info().device_type{
|
|
||||||
wgpu::DeviceType::IntegratedGpu=>3,
|
|
||||||
wgpu::DeviceType::DiscreteGpu=>4,
|
|
||||||
wgpu::DeviceType::VirtualGpu=>2,
|
|
||||||
wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
|
|
||||||
};
|
|
||||||
|
|
||||||
let adapter_features=adapter.features();
|
|
||||||
if chosen_adapter_score<score&&adapter_features.contains(required_features) {
|
|
||||||
chosen_adapter_score=score;
|
|
||||||
chosen_adapter=Some(adapter);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if let Some(maybe_chosen_adapter)=chosen_adapter{
|
|
||||||
adapter=maybe_chosen_adapter;
|
|
||||||
}else{
|
|
||||||
panic!("No suitable GPU adapters found on the system!");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
let adapter_info=adapter.get_info();
|
|
||||||
println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
|
|
||||||
|
|
||||||
let required_downlevel_capabilities=required_downlevel_capabilities();
|
|
||||||
let downlevel_capabilities=adapter.get_downlevel_capabilities();
|
|
||||||
assert!(
|
|
||||||
downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
|
|
||||||
"Adapter does not support the minimum shader model required to run this example: {:?}",
|
|
||||||
required_downlevel_capabilities.shader_model
|
|
||||||
);
|
|
||||||
assert!(
|
|
||||||
downlevel_capabilities
|
|
||||||
.flags
|
|
||||||
.contains(required_downlevel_capabilities.flags),
|
|
||||||
"Adapter does not support the downlevel capabilities required to run this example: {:?}",
|
|
||||||
required_downlevel_capabilities.flags - downlevel_capabilities.flags
|
|
||||||
);
|
|
||||||
SetupContextPartial3{
|
|
||||||
instance:self.instance,
|
|
||||||
surface:self.surface,
|
|
||||||
adapter,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct SetupContextPartial3<'a>{
|
|
||||||
instance:wgpu::Instance,
|
|
||||||
surface:wgpu::Surface<'a>,
|
|
||||||
adapter:wgpu::Adapter,
|
|
||||||
}
|
|
||||||
impl<'a> SetupContextPartial3<'a>{
|
|
||||||
fn request_device(self)->SetupContextPartial4<'a>{
|
|
||||||
let optional_features=optional_features();
|
|
||||||
let required_features=required_features();
|
|
||||||
|
|
||||||
// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
|
|
||||||
let needed_limits=required_limits().using_resolution(self.adapter.limits());
|
|
||||||
|
|
||||||
let trace_dir=std::env::var("WGPU_TRACE");
|
|
||||||
let (device, queue)=pollster::block_on(self.adapter
|
|
||||||
.request_device(
|
|
||||||
&wgpu::DeviceDescriptor {
|
|
||||||
label: None,
|
|
||||||
required_features: (optional_features & self.adapter.features()) | required_features,
|
|
||||||
required_limits: needed_limits,
|
|
||||||
},
|
|
||||||
trace_dir.ok().as_ref().map(std::path::Path::new),
|
|
||||||
))
|
|
||||||
.expect("Unable to find a suitable GPU adapter!");
|
|
||||||
|
|
||||||
SetupContextPartial4{
|
|
||||||
instance:self.instance,
|
|
||||||
surface:self.surface,
|
|
||||||
adapter:self.adapter,
|
|
||||||
device,
|
|
||||||
queue,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
struct SetupContextPartial4<'a>{
|
|
||||||
instance:wgpu::Instance,
|
|
||||||
surface:wgpu::Surface<'a>,
|
|
||||||
adapter:wgpu::Adapter,
|
|
||||||
device:wgpu::Device,
|
|
||||||
queue:wgpu::Queue,
|
|
||||||
}
|
|
||||||
impl<'a> SetupContextPartial4<'a>{
|
|
||||||
fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
|
|
||||||
let mut config=self.surface
|
|
||||||
.get_default_config(&self.adapter, size.width, size.height)
|
|
||||||
.expect("Surface isn't supported by the adapter.");
|
|
||||||
let surface_view_format=config.format.add_srgb_suffix();
|
|
||||||
config.view_formats.push(surface_view_format);
|
|
||||||
config.present_mode=wgpu::PresentMode::AutoNoVsync;
|
|
||||||
self.surface.configure(&self.device, &config);
|
|
||||||
|
|
||||||
SetupContext{
|
|
||||||
instance:self.instance,
|
|
||||||
surface:self.surface,
|
|
||||||
device:self.device,
|
|
||||||
queue:self.queue,
|
|
||||||
config,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub struct SetupContext<'a>{
|
|
||||||
pub instance:wgpu::Instance,
|
|
||||||
pub surface:wgpu::Surface<'a>,
|
|
||||||
pub device:wgpu::Device,
|
|
||||||
pub queue:wgpu::Queue,
|
|
||||||
pub config:wgpu::SurfaceConfiguration,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn setup_and_start(title:String){
|
|
||||||
let event_loop=winit::event_loop::EventLoop::new().unwrap();
|
|
||||||
|
|
||||||
println!("Initializing the surface...");
|
|
||||||
|
|
||||||
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_3=partial_2.pick_adapter();
|
|
||||||
|
|
||||||
let partial_4=partial_3.request_device();
|
|
||||||
|
|
||||||
let size=window.inner_size();
|
|
||||||
|
|
||||||
let setup_context=partial_4.configure_surface(&size);
|
|
||||||
|
|
||||||
//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);
|
|
||||||
|
|
||||||
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(
|
|
||||||
event_loop:winit::event_loop::EventLoop<()>,
|
|
||||||
mut window_thread:crate::compat_worker::QNWorker<TimedInstruction<WindowInstruction>>,
|
|
||||||
root_time:std::time::Instant
|
|
||||||
)->Result<(),winit::error::EventLoopError>{
|
|
||||||
event_loop.run(move |event,elwt|{
|
|
||||||
let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
|
|
||||||
// *control_flow=if cfg!(feature="metal-auto-capture"){
|
|
||||||
// winit::event_loop::ControlFlow::Exit
|
|
||||||
// }else{
|
|
||||||
// winit::event_loop::ControlFlow::Poll
|
|
||||||
// };
|
|
||||||
match event{
|
|
||||||
winit::event::Event::AboutToWait=>{
|
|
||||||
window_thread.send(TimedInstruction{time,instruction:WindowInstruction::RequestRedraw}).unwrap();
|
|
||||||
}
|
|
||||||
winit::event::Event::WindowEvent {
|
|
||||||
event:
|
|
||||||
// WindowEvent::Resized(size)
|
|
||||||
// | WindowEvent::ScaleFactorChanged {
|
|
||||||
// new_inner_size: &mut size,
|
|
||||||
// ..
|
|
||||||
// },
|
|
||||||
winit::event::WindowEvent::Resized(size),//ignoring scale factor changed for now because mutex bruh
|
|
||||||
window_id:_,
|
|
||||||
} => {
|
|
||||||
window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Resize(size)}).unwrap();
|
|
||||||
}
|
|
||||||
winit::event::Event::WindowEvent{event,..}=>match event{
|
|
||||||
winit::event::WindowEvent::KeyboardInput{
|
|
||||||
event:
|
|
||||||
winit::event::KeyEvent {
|
|
||||||
logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
|
|
||||||
state: winit::event::ElementState::Pressed,
|
|
||||||
..
|
|
||||||
},
|
|
||||||
..
|
|
||||||
}
|
|
||||||
|winit::event::WindowEvent::CloseRequested=>{
|
|
||||||
elwt.exit();
|
|
||||||
}
|
|
||||||
winit::event::WindowEvent::RedrawRequested=>{
|
|
||||||
window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Render}).unwrap();
|
|
||||||
}
|
|
||||||
_=>{
|
|
||||||
window_thread.send(TimedInstruction{time,instruction:WindowInstruction::WindowEvent(event)}).unwrap();
|
|
||||||
}
|
|
||||||
},
|
|
||||||
winit::event::Event::DeviceEvent{
|
|
||||||
event,
|
|
||||||
..
|
|
||||||
} => {
|
|
||||||
window_thread.send(TimedInstruction{time,instruction:WindowInstruction::DeviceEvent(event)}).unwrap();
|
|
||||||
},
|
|
||||||
_=>{}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
8
src/sweep.rs
Normal file
8
src/sweep.rs
Normal file
@ -0,0 +1,8 @@
|
|||||||
|
|
||||||
|
//something that implements body + hitbox + transform can predict collision
|
||||||
|
impl crate::sweep::PredictCollision for Model {
|
||||||
|
fn predict_collision(&self,other:&Model) -> Option<crate::event::EventStruct> {
|
||||||
|
//math!
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
244
src/window.rs
244
src/window.rs
@ -1,244 +0,0 @@
|
|||||||
use crate::physics_worker::InputInstruction;
|
|
||||||
use strafesnet_common::integer;
|
|
||||||
use strafesnet_common::instruction::TimedInstruction;
|
|
||||||
|
|
||||||
pub enum WindowInstruction{
|
|
||||||
Resize(winit::dpi::PhysicalSize<u32>),
|
|
||||||
WindowEvent(winit::event::WindowEvent),
|
|
||||||
DeviceEvent(winit::event::DeviceEvent),
|
|
||||||
RequestRedraw,
|
|
||||||
Render,
|
|
||||||
}
|
|
||||||
|
|
||||||
//holds thread handles to dispatch to
|
|
||||||
struct WindowContext<'a>{
|
|
||||||
manual_mouse_lock:bool,
|
|
||||||
mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
|
|
||||||
screen_size:glam::UVec2,
|
|
||||||
user_settings:crate::settings::UserSettings,
|
|
||||||
window:&'a winit::window::Window,
|
|
||||||
physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl WindowContext<'_>{
|
|
||||||
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)
|
|
||||||
}
|
|
||||||
fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) {
|
|
||||||
match event {
|
|
||||||
winit::event::WindowEvent::DroppedFile(path)=>{
|
|
||||||
//blocking because it's simpler...
|
|
||||||
if let Some(indexed_model_instances)=crate::load_file(path){
|
|
||||||
self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ClearModels}).unwrap();
|
|
||||||
self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::GenerateModels(indexed_model_instances)}).unwrap();
|
|
||||||
}
|
|
||||||
},
|
|
||||||
winit::event::WindowEvent::Focused(_state)=>{
|
|
||||||
//pause unpause
|
|
||||||
//recalculate pressed keys on focus
|
|
||||||
},
|
|
||||||
winit::event::WindowEvent::KeyboardInput{
|
|
||||||
event:winit::event::KeyEvent{state,logical_key,repeat:false,..},
|
|
||||||
..
|
|
||||||
}=>{
|
|
||||||
let s=match state{
|
|
||||||
winit::event::ElementState::Pressed=>true,
|
|
||||||
winit::event::ElementState::Released=>false,
|
|
||||||
};
|
|
||||||
match logical_key{
|
|
||||||
winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab)=>{
|
|
||||||
if s{
|
|
||||||
self.manual_mouse_lock=false;
|
|
||||||
match self.window.set_cursor_position(self.get_middle_of_screen()){
|
|
||||||
Ok(())=>(),
|
|
||||||
Err(e)=>println!("Could not set cursor position: {:?}",e),
|
|
||||||
}
|
|
||||||
match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
|
|
||||||
Ok(())=>(),
|
|
||||||
Err(e)=>println!("Could not release cursor: {:?}",e),
|
|
||||||
}
|
|
||||||
}else{
|
|
||||||
//if cursor is outside window don't lock but apparently there's no get pos function
|
|
||||||
//let pos=window.get_cursor_pos();
|
|
||||||
match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
|
|
||||||
Ok(())=>(),
|
|
||||||
Err(_)=>{
|
|
||||||
match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
|
|
||||||
Ok(())=>(),
|
|
||||||
Err(e)=>{
|
|
||||||
self.manual_mouse_lock=true;
|
|
||||||
println!("Could not confine cursor: {:?}",e)
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
self.window.set_cursor_visible(s);
|
|
||||||
},
|
|
||||||
winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11)=>{
|
|
||||||
if s{
|
|
||||||
if self.window.fullscreen().is_some(){
|
|
||||||
self.window.set_fullscreen(None);
|
|
||||||
}else{
|
|
||||||
self.window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape)=>{
|
|
||||||
if s{
|
|
||||||
self.manual_mouse_lock=false;
|
|
||||||
match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
|
|
||||||
Ok(())=>(),
|
|
||||||
Err(e)=>println!("Could not release cursor: {:?}",e),
|
|
||||||
}
|
|
||||||
self.window.set_cursor_visible(true);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
keycode=>{
|
|
||||||
if let Some(input_instruction)=match keycode{
|
|
||||||
winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
|
|
||||||
winit::keyboard::Key::Character(key)=>match key.as_str(){
|
|
||||||
"w"=>Some(InputInstruction::MoveForward(s)),
|
|
||||||
"a"=>Some(InputInstruction::MoveLeft(s)),
|
|
||||||
"s"=>Some(InputInstruction::MoveBack(s)),
|
|
||||||
"d"=>Some(InputInstruction::MoveRight(s)),
|
|
||||||
"e"=>Some(InputInstruction::MoveUp(s)),
|
|
||||||
"q"=>Some(InputInstruction::MoveDown(s)),
|
|
||||||
"z"=>Some(InputInstruction::Zoom(s)),
|
|
||||||
"r"=>if s{Some(InputInstruction::Reset)}else{None},
|
|
||||||
_=>None,
|
|
||||||
},
|
|
||||||
_=>None,
|
|
||||||
}{
|
|
||||||
self.physics_thread.send(TimedInstruction{
|
|
||||||
time,
|
|
||||||
instruction:crate::physics_worker::Instruction::Input(input_instruction),
|
|
||||||
}).unwrap();
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
|
||||||
},
|
|
||||||
_=>(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
|
|
||||||
match event {
|
|
||||||
winit::event::DeviceEvent::MouseMotion {
|
|
||||||
delta,//these (f64,f64) are integers on my machine
|
|
||||||
} => {
|
|
||||||
if self.manual_mouse_lock{
|
|
||||||
match self.window.set_cursor_position(self.get_middle_of_screen()){
|
|
||||||
Ok(())=>(),
|
|
||||||
Err(e)=>println!("Could not set cursor position: {:?}",e),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//do not step the physics because the mouse polling rate is higher than the physics can run.
|
|
||||||
//essentially the previous input will be overwritten until a true step runs
|
|
||||||
//which is fine because they run all the time.
|
|
||||||
let delta=glam::ivec2(delta.0 as i32,delta.1 as i32);
|
|
||||||
self.mouse.pos+=delta;
|
|
||||||
self.physics_thread.send(TimedInstruction{
|
|
||||||
time,
|
|
||||||
instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
|
|
||||||
}).unwrap();
|
|
||||||
},
|
|
||||||
winit::event::DeviceEvent::MouseWheel {
|
|
||||||
delta,
|
|
||||||
} => {
|
|
||||||
println!("mousewheel {:?}",delta);
|
|
||||||
if false{//self.physics.style.use_scroll{
|
|
||||||
self.physics_thread.send(TimedInstruction{
|
|
||||||
time,
|
|
||||||
instruction:crate::physics_worker::Instruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
|
|
||||||
}).unwrap();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
_=>(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct WindowContextSetup<'a>{
|
|
||||||
user_settings:crate::settings::UserSettings,
|
|
||||||
window:&'a winit::window::Window,
|
|
||||||
physics:crate::physics::PhysicsState,
|
|
||||||
graphics:crate::graphics::GraphicsState,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> WindowContextSetup<'a>{
|
|
||||||
pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
|
|
||||||
//wee
|
|
||||||
let user_settings=crate::settings::read_user_settings();
|
|
||||||
|
|
||||||
let args:Vec<String>=std::env::args().collect();
|
|
||||||
let indexed_model_instances=if args.len()==2{
|
|
||||||
crate::load_file(std::path::PathBuf::from(&args[1]))
|
|
||||||
}else{
|
|
||||||
None
|
|
||||||
}.unwrap_or(crate::default_models());
|
|
||||||
|
|
||||||
let mut physics=crate::physics::PhysicsState::default();
|
|
||||||
physics.load_user_settings(&user_settings);
|
|
||||||
physics.generate_models(&indexed_model_instances);
|
|
||||||
physics.spawn(indexed_model_instances.spawn_point);
|
|
||||||
|
|
||||||
let mut graphics=crate::graphics::GraphicsState::new(&context.device,&context.queue,&context.config);
|
|
||||||
graphics.load_user_settings(&user_settings);
|
|
||||||
graphics.generate_models(&context.device,&context.queue,indexed_model_instances);
|
|
||||||
|
|
||||||
Self{
|
|
||||||
user_settings,
|
|
||||||
window,
|
|
||||||
graphics,
|
|
||||||
physics,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{
|
|
||||||
let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
|
|
||||||
let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
|
|
||||||
WindowContext{
|
|
||||||
manual_mouse_lock:false,
|
|
||||||
mouse:crate::physics::MouseState::default(),
|
|
||||||
//make sure to update this!!!!!
|
|
||||||
screen_size,
|
|
||||||
user_settings:self.user_settings,
|
|
||||||
window:self.window,
|
|
||||||
physics_thread:crate::physics_worker::new(self.physics,graphics_thread),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
|
|
||||||
let mut window_context=self.into_context(setup_context);
|
|
||||||
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
|
|
||||||
match ins.instruction{
|
|
||||||
WindowInstruction::RequestRedraw=>{
|
|
||||||
window_context.window.request_redraw();
|
|
||||||
}
|
|
||||||
WindowInstruction::WindowEvent(window_event)=>{
|
|
||||||
window_context.window_event(ins.time,window_event);
|
|
||||||
},
|
|
||||||
WindowInstruction::DeviceEvent(device_event)=>{
|
|
||||||
window_context.device_event(ins.time,device_event);
|
|
||||||
},
|
|
||||||
WindowInstruction::Resize(size)=>{
|
|
||||||
window_context.physics_thread.send(
|
|
||||||
TimedInstruction{
|
|
||||||
time:ins.time,
|
|
||||||
instruction:crate::physics_worker::Instruction::Resize(size,window_context.user_settings.clone())
|
|
||||||
}
|
|
||||||
).unwrap();
|
|
||||||
}
|
|
||||||
WindowInstruction::Render=>{
|
|
||||||
window_context.physics_thread.send(
|
|
||||||
TimedInstruction{
|
|
||||||
time:ins.time,
|
|
||||||
instruction:crate::physics_worker::Instruction::Render
|
|
||||||
}
|
|
||||||
).unwrap();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
159
src/worker.rs
159
src/worker.rs
@ -2,68 +2,16 @@ use std::thread;
|
|||||||
use std::sync::{mpsc,Arc};
|
use std::sync::{mpsc,Arc};
|
||||||
use parking_lot::Mutex;
|
use parking_lot::Mutex;
|
||||||
|
|
||||||
//WorkerPool
|
|
||||||
struct Pool(u32);
|
|
||||||
enum PoolOrdering{
|
|
||||||
Single,//single thread cannot get out of order
|
|
||||||
Ordered(u32),//order matters and should be buffered/dropped according to ControlFlow
|
|
||||||
Unordered(u32),//order does not matter
|
|
||||||
}
|
|
||||||
//WorkerInput
|
|
||||||
enum Input{
|
|
||||||
//no input, workers have everything needed at creation
|
|
||||||
None,
|
|
||||||
//Immediate input to any available worker, dropped if they are overflowing (all workers are busy)
|
|
||||||
Immediate,
|
|
||||||
//Queued input is ordered, but serial jobs that mutate state (such as running physics) can only be done with a single worker
|
|
||||||
Queued,//"Fifo"
|
|
||||||
//Query a function to get next input when a thread becomes available
|
|
||||||
//worker stops querying when Query function returns None and dies after all threads complete
|
|
||||||
//lifetimes sound crazy on this one
|
|
||||||
Query,
|
|
||||||
//Queue of length one, the input is replaced if it is submitted twice before the current work finishes
|
|
||||||
Mailbox,
|
|
||||||
}
|
|
||||||
//WorkerOutput
|
|
||||||
enum Output{
|
|
||||||
None(Pool),
|
|
||||||
Realtime(PoolOrdering),//outputs are dropped if they are out of order and order is demanded
|
|
||||||
Buffered(PoolOrdering),//outputs are held back internally if they are out of order and order is demanded
|
|
||||||
}
|
|
||||||
|
|
||||||
//It would be possible to implement all variants
|
|
||||||
//with a query input function and callback output function but I'm not sure if that's worth it.
|
|
||||||
//Immediate = Condvar
|
|
||||||
//Queued = receiver.recv()
|
|
||||||
//a callback function would need to use an async runtime!
|
|
||||||
|
|
||||||
//realtime output is an arc mutex of the output value that is assigned every time a worker completes a job
|
|
||||||
//buffered output produces a receiver object that can be passed to the creation of another worker
|
|
||||||
//when ordering is requested, output is ordered by the order each thread is run
|
|
||||||
//which is the same as the order that the input data is processed except for Input::None which has no input data
|
|
||||||
//WorkerDescription
|
|
||||||
struct Description{
|
|
||||||
input:Input,
|
|
||||||
output:Output,
|
|
||||||
}
|
|
||||||
|
|
||||||
//The goal here is to have a worker thread that parks itself when it runs out of work.
|
//The goal here is to have a worker thread that parks itself when it runs out of work.
|
||||||
//The worker thread publishes the result of its work back to the worker object for every item in the work queue.
|
//The worker thread publishes the result of its work back to the worker object for every item in the work queue.
|
||||||
//Previous values do not matter as soon as a new value is produced, which is why it's called "Realtime"
|
|
||||||
//The physics (target use case) knows when it has not changed the body, so not updating the value is also an option.
|
//The physics (target use case) knows when it has not changed the body, so not updating the value is also an option.
|
||||||
|
|
||||||
/*
|
pub struct Worker<Task:Send,Value:Clone> {
|
||||||
QR = WorkerDescription{
|
|
||||||
input:Queued,
|
|
||||||
output:Realtime(Single),
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
pub struct QRWorker<Task:Send,Value:Clone>{
|
|
||||||
sender: mpsc::Sender<Task>,
|
sender: mpsc::Sender<Task>,
|
||||||
value:Arc<Mutex<Value>>,
|
value:Arc<Mutex<Value>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<Task:Send+'static,Value:Clone+Send+'static> QRWorker<Task,Value>{
|
impl<Task:Send+'static,Value:Clone+Send+'static> Worker<Task,Value> {
|
||||||
pub fn new<F:FnMut(Task)->Value+Send+'static>(value:Value,mut f:F) -> Self {
|
pub fn new<F:FnMut(Task)->Value+Send+'static>(value:Value,mut f:F) -> Self {
|
||||||
let (sender, receiver) = mpsc::channel::<Task>();
|
let (sender, receiver) = mpsc::channel::<Task>();
|
||||||
let ret=Self {
|
let ret=Self {
|
||||||
@ -97,94 +45,43 @@ impl<Task:Send+'static,Value:Clone+Send+'static> QRWorker<Task,Value>{
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
pub struct CompatWorker<Task,Value:Clone,F>{
|
||||||
QN = WorkerDescription{
|
data:std::marker::PhantomData<Task>,
|
||||||
input:Queued,
|
f:F,
|
||||||
output:None(Single),
|
value:Value,
|
||||||
}
|
|
||||||
*/
|
|
||||||
//None Output Worker does all its work internally from the perspective of the work submitter
|
|
||||||
pub struct QNWorker<'a,Task:Send>{
|
|
||||||
sender: mpsc::Sender<Task>,
|
|
||||||
handle:thread::ScopedJoinHandle<'a,()>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'a,Task:Send+'a> QNWorker<'a,Task>{
|
impl<Task,Value:Clone,F:FnMut(Task)->Value> CompatWorker<Task,Value,F> {
|
||||||
pub fn new<F:FnMut(Task)+Send+'a>(scope:&'a thread::Scope<'a,'_>,mut f:F)->QNWorker<'a,Task>{
|
pub fn new(value:Value,f:F) -> Self {
|
||||||
let (sender,receiver)=mpsc::channel::<Task>();
|
Self {
|
||||||
let handle=scope.spawn(move ||{
|
f,
|
||||||
loop {
|
value,
|
||||||
match receiver.recv() {
|
data:std::marker::PhantomData,
|
||||||
Ok(task)=>f(task),
|
|
||||||
Err(_)=>{
|
|
||||||
println!("Worker stopping.",);
|
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
|
||||||
});
|
|
||||||
Self{
|
|
||||||
sender,
|
|
||||||
handle,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn send(&self,task:Task)->Result<(),mpsc::SendError<Task>>{
|
|
||||||
self.sender.send(task)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
pub fn send(&mut self,task:Task)->Result<(),()>{
|
||||||
IN = WorkerDescription{
|
self.value=(self.f)(task);
|
||||||
input:Immediate,
|
Ok(())
|
||||||
output:None(Single),
|
}
|
||||||
}
|
|
||||||
*/
|
|
||||||
//Inputs are dropped if the worker is busy
|
|
||||||
pub struct INWorker<'a,Task:Send>{
|
|
||||||
sender: mpsc::SyncSender<Task>,
|
|
||||||
handle:thread::ScopedJoinHandle<'a,()>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a,Task:Send+'a> INWorker<'a,Task>{
|
pub fn grab_clone(&self)->Value{
|
||||||
pub fn new<F:FnMut(Task)+Send+'a>(scope:&'a thread::Scope<'a,'_>,mut f:F)->INWorker<'a,Task>{
|
self.value.clone()
|
||||||
let (sender,receiver)=mpsc::sync_channel::<Task>(1);
|
|
||||||
let handle=scope.spawn(move ||{
|
|
||||||
loop {
|
|
||||||
match receiver.recv() {
|
|
||||||
Ok(task)=>f(task),
|
|
||||||
Err(_)=>{
|
|
||||||
println!("Worker stopping.",);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
Self{
|
|
||||||
sender,
|
|
||||||
handle,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
//blocking!
|
|
||||||
pub fn blocking_send(&self,task:Task)->Result<(), mpsc::SendError<Task>>{
|
|
||||||
self.sender.send(task)
|
|
||||||
}
|
|
||||||
pub fn send(&self,task:Task)->Result<(), mpsc::TrySendError<Task>>{
|
|
||||||
self.sender.try_send(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 = Worker::new(crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO),
|
||||||
let worker=QRWorker::new(crate::physics::Body::default(),
|
|_|crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE)
|
||||||
|_|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 = strafesnet_common::instruction::TimedInstruction{
|
let task = crate::instruction::TimedInstruction{
|
||||||
time:strafesnet_common::integer::Time::ZERO,
|
time:crate::integer::Time::ZERO,
|
||||||
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
||||||
};
|
};
|
||||||
worker.send(task).unwrap();
|
worker.send(task).unwrap();
|
||||||
@ -194,17 +91,17 @@ fn test_worker() {
|
|||||||
// sender.send("STOP".to_string()).unwrap();
|
// sender.send("STOP".to_string()).unwrap();
|
||||||
|
|
||||||
// Sleep to allow the worker thread to finish processing
|
// Sleep to allow the worker thread to finish processing
|
||||||
thread::sleep(std::time::Duration::from_millis(10));
|
thread::sleep(std::time::Duration::from_secs(2));
|
||||||
|
|
||||||
// Send a new task
|
// Send a new task
|
||||||
let task = strafesnet_common::instruction::TimedInstruction{
|
let task = crate::instruction::TimedInstruction{
|
||||||
time:strafesnet_common::integer::Time::ZERO,
|
time:crate::integer::Time::ZERO,
|
||||||
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
instruction:crate::physics::PhysicsInstruction::StrafeTick,
|
||||||
};
|
};
|
||||||
worker.send(task).unwrap();
|
worker.send(task).unwrap();
|
||||||
|
|
||||||
//assert_eq!(test_body,worker.grab_clone());
|
println!("value={}",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_secs(1));
|
||||||
}
|
}
|
||||||
|
32
src/zeroes.rs
Normal file
32
src/zeroes.rs
Normal file
@ -0,0 +1,32 @@
|
|||||||
|
//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 mut 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
|
||||||
|
if Planar64::ZERO<a2 {
|
||||||
|
return vec![(-a1-planar_radicand)/(a2*2),(-a1+planar_radicand)/(a2*2)];
|
||||||
|
} else {
|
||||||
|
return vec![(-a1+planar_radicand)/(a2*2),(-a1-planar_radicand)/(a2*2)];
|
||||||
|
}
|
||||||
|
} 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];
|
||||||
|
}
|
||||||
|
}
|
@ -1 +0,0 @@
|
|||||||
mangohud ../target/release/strafe-client bhop_maps/5692113331.rbxm
|
|
@ -1 +0,0 @@
|
|||||||
/run/media/quat/Files/Documents/map-files/verify-scripts/maps/bhop_all/
|
|
@ -1 +0,0 @@
|
|||||||
cargo build --release --target x86_64-pc-windows-gnu
|
|
@ -1,4 +0,0 @@
|
|||||||
mkdir -p ../target/demo
|
|
||||||
mv ../target/x86_64-pc-windows-gnu/release/strafe-client.exe ../target/demo/strafe-client.exe
|
|
||||||
rm ../target/demo.7z
|
|
||||||
7z a -t7z -mx=9 -mfb=273 -ms -md=31 -myx=9 -mtm=- -mmt -mmtf -md=1536m -mmf=bt3 -mmc=10000 -mpb=0 -mlc=0 ../target/demo.7z ../target/demo
|
|
@ -1,4 +0,0 @@
|
|||||||
[camera]
|
|
||||||
sensitivity_x=98384
|
|
||||||
fov_y=1.0
|
|
||||||
#fov_x_from_y_ratio=1.33333333333333333333333333333333
|
|
@ -1 +0,0 @@
|
|||||||
/run/media/quat/Files/Documents/map-files/verify-scripts/maps/surf_all/
|
|
@ -1 +0,0 @@
|
|||||||
/run/media/quat/Files/Documents/map-files/verify-scripts/textures/dds/
|
|
@ -1 +0,0 @@
|
|||||||
mangohud ../target/release/strafe-client bhop_maps/5692152916.rbxm
|
|
@ -1 +0,0 @@
|
|||||||
mangohud ../target/release/strafe-client surf_maps/5692145408.rbxm
|
|
Loading…
Reference in New Issue
Block a user