interpreterK/strafe-client
1
Fork 0
forked from StrafesNET/strafe-client
Code Issues Pull Requests Packages Projects Releases Wiki Activity

commonize

Browse Source
This commit is contained in:
Quaternions 2024-01-29 16:19:41 -08:00
parent 515ca20fb5
commit 480cd0e3be
22 changed files with 88 additions and 1387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Cargo.lock generated
View File

@ -1648,12 +1648,21 @@ dependencies = [
"rbx_dom_weak",
"rbx_reflection_database",
"rbx_xml",
"strafesnet_common",
"vbsp",
"vmdl",
"wgpu",
"winit",
]
[[package]]
name = "strafesnet_common"
version = "0.1.0"
source = "git+https://git.itzana.me/StrafesNET/common?rev=434ca29aef7e3015c9ca1ed45de8fef42e33fdfb#434ca29aef7e3015c9ca1ed45de8fef42e33fdfb"
dependencies = [
"glam",
]
[[package]]
name = "strict-num"
version = "0.1.1"

1
Cargo.toml
View File

@ -18,6 +18,7 @@ rbx_binary = "0.7.1"
rbx_dom_weak = "2.5.0"
rbx_reflection_database = "0.2.7"
rbx_xml = "0.13.1"
strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "434ca29aef7e3015c9ca1ed45de8fef42e33fdfb" }
vbsp = "0.5.0"
vmdl = "0.1.1"
wgpu = "0.19.0"

46
src/aabb.rs
View File

@ -1,46 +0,0 @@
use crate::integer::Planar64Vec3;
#[derive(Clone)]
pub struct Aabb{
min:Planar64Vec3,
max:Planar64Vec3,
}
impl Default for Aabb {
fn default()->Self {
Self{min:Planar64Vec3::MAX,max:Planar64Vec3::MIN}
}
}
impl Aabb{
pub fn grow(&mut self,point:Planar64Vec3){
self.min=self.min.min(point);
self.max=self.max.max(point);
}
pub fn join(&mut self,aabb:&Aabb){
self.min=self.min.min(aabb.min);
self.max=self.max.max(aabb.max);
}
pub fn inflate(&mut self,hs:Planar64Vec3){
self.min-=hs;
self.max+=hs;
}
pub fn intersects(&self,aabb:&Aabb)->bool{
(self.min.cmplt(aabb.max)&aabb.min.cmplt(self.max)).all()
}
pub fn size(&self)->Planar64Vec3{
self.max-self.min
}
pub fn center(&self)->Planar64Vec3{
self.min.midpoint(self.max)
}
//probably use floats for area & volume because we don't care about precision
// pub fn area_weight(&self)->f32{
// let d=self.max-self.min;
// d.x*d.y+d.y*d.z+d.z*d.x
// }
// pub fn volume(&self)->f32{
// let d=self.max-self.min;
// d.x*d.y*d.z
// }
}

123
src/bvh.rs
View File

@ -1,123 +0,0 @@
use crate::aabb::Aabb;
//da algaritum
//lista boxens
//sort by {minx,maxx,miny,maxy,minz,maxz} (6 lists)
//find the sets that minimizes the sum of surface areas
//splitting is done when the minimum split sum of surface areas is larger than the node's own surface area
//start with bisection into octrees because a bad bvh is still 1000x better than no bvh
//sort the centerpoints on each axis (3 lists)
//bv is put into octant based on whether it is upper or lower in each list
enum BvhNodeContent{
Branch(Vec<BvhNode>),
Leaf(usize),
}
impl Default for BvhNodeContent{
fn default()->Self{
Self::Branch(Vec::new())
}
}
#[derive(Default)]
pub struct BvhNode{
content:BvhNodeContent,
aabb:Aabb,
}
impl BvhNode{
pub fn the_tester<F:FnMut(usize)>(&self,aabb:&Aabb,f:&mut F){
match &self.content{
&BvhNodeContent::Leaf(model)=>f(model),
BvhNodeContent::Branch(children)=>for child in children{
//this test could be moved outside the match statement
//but that would test the root node aabb
//you're probably not going to spend a lot of time outside the map,
//so the test is extra work for nothing
if aabb.intersects(&child.aabb){
child.the_tester(aabb,f);
}
},
}
}
}
pub fn generate_bvh(boxen:Vec<Aabb>)->BvhNode{
generate_bvh_node(boxen.into_iter().enumerate().collect())
}
fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
let n=boxen.len();
if n<20{
let mut aabb=Aabb::default();
let nodes=boxen.into_iter().map(|b|{
aabb.join(&b.1);
BvhNode{
content:BvhNodeContent::Leaf(b.0),
aabb:b.1,
}
}).collect();
BvhNode{
content:BvhNodeContent::Branch(nodes),
aabb,
}
}else{
let mut octant=std::collections::HashMap::with_capacity(n);//this ids which octant the boxen is put in
let mut sort_x=Vec::with_capacity(n);
let mut sort_y=Vec::with_capacity(n);
let mut sort_z=Vec::with_capacity(n);
for (i,aabb) in boxen.iter(){
let center=aabb.center();
octant.insert(*i,0);
sort_x.push((*i,center.x()));
sort_y.push((*i,center.y()));
sort_z.push((*i,center.z()));
}
sort_x.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
sort_y.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
sort_z.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
let h=n/2;
let median_x=sort_x[h].1;
let median_y=sort_y[h].1;
let median_z=sort_z[h].1;
for (i,c) in sort_x{
if median_x<c{
octant.insert(i,octant[&i]+1<<0);
}
}
for (i,c) in sort_y{
if median_y<c{
octant.insert(i,octant[&i]+1<<1);
}
}
for (i,c) in sort_z{
if median_z<c{
octant.insert(i,octant[&i]+1<<2);
}
}
//generate lists for unique octant values
let mut list_list=Vec::with_capacity(8);
let mut octant_list=Vec::with_capacity(8);
for (i,aabb) in boxen.into_iter(){
let octant_id=octant[&i];
let list_id=if let Some(list_id)=octant_list.iter().position(|&id|id==octant_id){
list_id
}else{
let list_id=list_list.len();
octant_list.push(octant_id);
list_list.push(Vec::new());
list_id
};
list_list[list_id].push((i,aabb));
}
let mut aabb=Aabb::default();
let children=list_list.into_iter().map(|b|{
let node=generate_bvh_node(b);
aabb.join(&node.aabb);
node
}).collect();
BvhNode{
content:BvhNodeContent::Branch(children),
aabb,
}
}
}

4
src/face_crawler.rs
View File

@ -1,7 +1,7 @@
use crate::physics::Body;
use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
use crate::integer::{Time,Planar64};
use crate::zeroes::zeroes2;
use strafesnet_common::integer::{Time,Planar64};
use strafesnet_common::zeroes::zeroes2;
enum Transition<F,E:DirectedEdge,V>{
Miss,

5
src/graphics.rs
View File

@ -1,4 +1,5 @@
use std::borrow::Cow;
use strafesnet_common::integer;
use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
@ -833,7 +834,7 @@ impl GraphicsState{
});
let camera=GraphicsCamera::default();
let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,crate::integer::Time::ZERO));
let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,integer::Time::ZERO));
let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Camera"),
contents: bytemuck::cast_slice(&camera_uniforms),
@ -902,7 +903,7 @@ impl GraphicsState{
device:&wgpu::Device,
queue:&wgpu::Queue,
physics_output:crate::physics::PhysicsOutputState,
predicted_time:crate::integer::Time,
predicted_time:integer::Time,
mouse_pos:glam::IVec2,
) {
//TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input

4
src/graphics_worker.rs
View File

@ -1,5 +1,7 @@
use strafesnet_common::integer;
pub enum Instruction{
Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2),
//UpdateModel(crate::graphics::GraphicsModelUpdate),
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
GenerateModels(crate::model::IndexedModelInstances),

53
src/instruction.rs
View File

@ -1,53 +0,0 @@
use crate::integer::Time;
#[derive(Debug)]
pub struct TimedInstruction<I>{
pub time:Time,
pub instruction:I,
}
pub trait InstructionEmitter<I>{
fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<I>>;
}
pub trait InstructionConsumer<I>{
fn process_instruction(&mut self, instruction:TimedInstruction<I>);
}
//PROPER PRIVATE FIELDS!!!
pub struct InstructionCollector<I>{
time:Time,
instruction:Option<I>,
}
impl<I> InstructionCollector<I>{
pub fn new(time:Time)->Self{
Self{
time,
instruction:None
}
}
#[inline]
pub fn time(&self)->Time{
self.time
}
pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
match instruction{
Some(unwrap_instruction)=>{
if unwrap_instruction.time<self.time {
self.time=unwrap_instruction.time;
self.instruction=Some(unwrap_instruction.instruction);
}
},
None=>(),
}
}
pub fn instruction(self)->Option<TimedInstruction<I>>{
//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
match self.instruction{
Some(instruction)=>Some(TimedInstruction{
time:self.time,
instruction
}),
None=>None,
}
}
}

1054
src/integer.rs
View File

File diff suppressed because it is too large Load Diff

16
src/load_bsp.rs
View File

@ -1,6 +1,8 @@
use strafesnet_common::integer;
const VALVE_SCALE:f32=1.0/16.0;
fn valve_transform(v:[f32;3])->crate::integer::Planar64Vec3{
crate::integer::Planar64Vec3::try_from([v[0]*VALVE_SCALE,v[2]*VALVE_SCALE,-v[1]*VALVE_SCALE]).unwrap()
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();
@ -12,7 +14,7 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
match vbsp::Bsp::read(s.as_slice()){
Ok(bsp)=>{
let mut spawn_point=crate::integer::Planar64Vec3::ZERO;
let mut spawn_point=integer::Planar64Vec3::ZERO;
let vertices: Vec<_> = bsp
.vertices
@ -86,8 +88,8 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
groups,
instances:vec![crate::model::ModelInstance{
attributes:crate::model::CollisionAttributes::Decoration,
transform:crate::integer::Planar64Affine3::new(
crate::integer::Planar64Mat3::default(),
transform:integer::Planar64Affine3::new(
integer::Planar64Mat3::default(),
valve_transform(<[f32;3]>::from(world_model.origin))
),
..Default::default()
@ -196,8 +198,8 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
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:crate::integer::Planar64Affine3::new(
crate::integer::Planar64Mat3::try_from(
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(

2
src/load_roblox.rs
View File

@ -1,5 +1,5 @@
use crate::primitives;
use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
use strafesnet_common::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
fn class_is_a(class: &str, superclass: &str) -> bool {
if class==superclass {

7
src/main.rs
View File

@ -1,16 +1,13 @@
mod bvh;
mod aabb;
use strafesnet_common::integer;
mod model;
mod setup;
mod window;
mod worker;
mod zeroes;
mod integer;
mod physics;
mod graphics;
mod settings;
mod primitives;
mod instruction;
mod load_bsp;
mod load_roblox;
mod face_crawler;

2
src/model.rs
View File

@ -1,4 +1,4 @@
use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
use strafesnet_common::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
pub type TextureCoordinate=glam::Vec2;
pub type Color4=glam::Vec4;
#[derive(Clone,Hash,PartialEq,Eq)]

29
src/model_physics.rs
View File

@ -1,5 +1,6 @@
use crate::integer::{Planar64,Planar64Vec3};
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);
@ -236,15 +237,15 @@ impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
pub struct TransformedMesh<'a>{
mesh:&'a PhysicsMesh,
transform:&'a crate::integer::Planar64Affine3,
normal_transform:&'a crate::integer::Planar64Mat3,
transform:&'a integer::Planar64Affine3,
normal_transform:&'a integer::Planar64Mat3,
transform_det:Planar64,
}
impl TransformedMesh<'_>{
pub fn new<'a>(
mesh:&'a PhysicsMesh,
transform:&'a crate::integer::Planar64Affine3,
normal_transform:&'a crate::integer::Planar64Mat3,
transform:&'a integer::Planar64Affine3,
normal_transform:&'a integer::Planar64Mat3,
transform_det:Planar64,
)->TransformedMesh<'a>{
TransformedMesh{
@ -389,7 +390,7 @@ impl MinkowskiMesh<'_>{
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 crate::zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
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);
@ -407,7 +408,7 @@ impl MinkowskiMesh<'_>{
//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 crate::zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
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{
@ -459,7 +460,7 @@ impl MinkowskiMesh<'_>{
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&&crate::zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
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);
}
@ -475,13 +476,13 @@ impl MinkowskiMesh<'_>{
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,crate::integer::Time::MIN,infinity_body.time){
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:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
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){
@ -490,7 +491,7 @@ impl MinkowskiMesh<'_>{
}
})
}
pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::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),
@ -506,7 +507,7 @@ impl MinkowskiMesh<'_>{
}
})
}
pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,crate::integer::Time)>{
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;
@ -519,8 +520,8 @@ impl MinkowskiMesh<'_>{
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 crate::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+crate::integer::Time::from(t);
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);

52
src/physics.rs
View File

@ -1,6 +1,8 @@
use crate::instruction::{InstructionEmitter,InstructionConsumer,TimedInstruction};
use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
use crate::model_physics::{PhysicsMesh,TransformedMesh,MeshQuery};
use strafesnet_common::bvh;
use strafesnet_common::aabb;
use strafesnet_common::instruction::{self,InstructionEmitter,InstructionConsumer,TimedInstruction};
use strafesnet_common::integer::{self,Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
#[derive(Debug)]
pub enum PhysicsInstruction {
@ -186,9 +188,9 @@ impl PhysicsModels{
self.attributes.clear();
self.model_id_from_wormhole_id.clear();
}
fn aabb_list(&self)->Vec<crate::aabb::Aabb>{
fn aabb_list(&self)->Vec<aabb::Aabb>{
self.models.iter().map(|model|{
let mut aabb=crate::aabb::Aabb::default();
let mut aabb=aabb::Aabb::default();
for pos in self.meshes[model.mesh_id].verts(){
aabb.grow(model.transform.transform_point3(pos));
}
@ -342,14 +344,14 @@ struct StrafeSettings{
struct Hitbox{
halfsize:Planar64Vec3,
mesh:PhysicsMesh,
transform:crate::integer::Planar64Affine3,
transform:integer::Planar64Affine3,
normal_transform:Planar64Mat3,
transform_det:Planar64,
}
impl Hitbox{
fn new(mesh:PhysicsMesh,transform:crate::integer::Planar64Affine3)->Self{
fn new(mesh:PhysicsMesh,transform:integer::Planar64Affine3)->Self{
//calculate extents
let mut aabb=crate::aabb::Aabb::default();
let mut aabb=aabb::Aabb::default();
for vert in mesh.verts(){
aabb.grow(transform.transform_point3(vert));
}
@ -367,7 +369,7 @@ impl Hitbox{
halfsize:scale,
mesh,
normal_transform:matrix3.inverse_times_det().transpose(),
transform:crate::integer::Planar64Affine3::new(matrix3,Planar64Vec3::ZERO),
transform:integer::Planar64Affine3::new(matrix3,Planar64Vec3::ZERO),
transform_det:matrix3.determinant(),//scale.x*scale.y*scale.z but whatever
}
}
@ -377,7 +379,7 @@ impl Hitbox{
halfsize:scale,
mesh,
normal_transform:matrix3.inverse_times_det().transpose(),
transform:crate::integer::Planar64Affine3::new(matrix3,offset),
transform:integer::Planar64Affine3::new(matrix3,offset),
transform_det:matrix3.determinant(),
}
}
@ -736,7 +738,7 @@ pub struct PhysicsState{
controls:u32,
move_state:MoveState,
models:PhysicsModels,
bvh:crate::bvh::BvhNode,
bvh:bvh::BvhNode,
modes:Modes,
//the spawn point is where you spawn when you load into the map.
@ -783,13 +785,13 @@ pub struct PhysicsModel{
//in this iteration, all it needs is extents.
mesh_id:usize,
attr_id:usize,
transform:crate::integer::Planar64Affine3,
normal_transform:crate::integer::Planar64Mat3,
transform:integer::Planar64Affine3,
normal_transform:integer::Planar64Mat3,
transform_det:Planar64,
}
impl PhysicsModel{
pub fn new(mesh_id:usize,attr_id:usize,transform:crate::integer::Planar64Affine3)->Self{
pub fn new(mesh_id:usize,attr_id:usize,transform:integer::Planar64Affine3)->Self{
Self{
mesh_id,
attr_id,
@ -944,7 +946,7 @@ impl TouchingState{
self.constrain_acceleration(models,&style_mesh,&mut a);
(move_state,a)
}
fn predict_collision_end(&self,collector:&mut crate::instruction::InstructionCollector<PhysicsInstruction>,models:&PhysicsModels,style_mesh:&TransformedMesh,body:&Body,time:Time){
fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<PhysicsInstruction>,models:&PhysicsModels,style_mesh:&TransformedMesh,body:&Body,time:Time){
let relative_body=VirtualBody::relative(&Body::default(),body).body(time);
for contact in &self.contacts{
//detect face slide off
@ -1008,7 +1010,7 @@ impl Body{
Some(self.velocity)
}
}
pub fn grow_aabb(&self,aabb:&mut crate::aabb::Aabb,t0:Time,t1:Time){
pub fn grow_aabb(&self,aabb:&mut aabb::Aabb,t0:Time,t1:Time){
aabb.grow(self.extrapolated_position(t0));
aabb.grow(self.extrapolated_position(t1));
//v+a*t==0
@ -1076,7 +1078,7 @@ impl Default for PhysicsState{
style:StyleModifiers::default(),
touching:TouchingState::default(),
models:PhysicsModels::default(),
bvh:crate::bvh::BvhNode::default(),
bvh:bvh::BvhNode::default(),
move_state: MoveState::Air,
camera:PhysicsCamera::default(),
next_mouse:MouseState::default(),
@ -1093,7 +1095,7 @@ impl PhysicsState {
self.models.clear();
self.modes.clear();
self.touching.clear();
self.bvh=crate::bvh::BvhNode::default();
self.bvh=bvh::BvhNode::default();
}
pub fn output(&self)->PhysicsOutputState{
@ -1107,7 +1109,7 @@ impl PhysicsState {
pub fn spawn(&mut self,spawn_point:Planar64Vec3){
self.game.stage_id=0;
self.spawn_point=spawn_point;
self.process_instruction(crate::instruction::TimedInstruction{
self.process_instruction(instruction::TimedInstruction{
time:self.time,
instruction: PhysicsInstruction::Input(PhysicsInputInstruction::Reset),
});
@ -1145,7 +1147,7 @@ impl PhysicsState {
self.models.push_mesh(PhysicsMesh::from(model));
}
}
self.bvh=crate::bvh::generate_bvh(self.models.aabb_list());
self.bvh=bvh::generate_bvh(self.models.aabb_list());
//I don't wanna write structs for temporary structures
//this code builds ModeDescriptions from the unsorted lists at the top of the function
starts.sort_by_key(|tup|tup.1.mode_id);
@ -1281,11 +1283,11 @@ impl PhysicsState {
}
}
impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState{
impl instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState{
//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<PhysicsInstruction>>{
//JUST POLLING!!! NO MUTATION
let mut collector = crate::instruction::InstructionCollector::new(time_limit);
let mut collector = instruction::InstructionCollector::new(time_limit);
collector.collect(self.next_move_instruction());
@ -1293,7 +1295,7 @@ impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState
//check for collision ends
self.touching.predict_collision_end(&mut collector,&self.models,&style_mesh,&self.body,self.time);
//check for collision starts
let mut aabb=crate::aabb::Aabb::default();
let mut aabb=aabb::Aabb::default();
self.body.grow_aabb(&mut aabb,self.time,collector.time());
aabb.inflate(self.style.hitbox.halfsize);
//common body
@ -1464,7 +1466,7 @@ fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehav
}
}
impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
fn process_instruction(&mut self, ins:TimedInstruction<PhysicsInstruction>) {
match &ins.instruction{
PhysicsInstruction::Input(PhysicsInputInstruction::Idle)
@ -1687,8 +1689,8 @@ fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option
#[allow(dead_code)]
fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
let h0=Hitbox::new(PhysicsMesh::from(&crate::primitives::unit_cube()),
crate::integer::Planar64Affine3::new(
crate::integer::Planar64Mat3::from_cols(
integer::Planar64Affine3::new(
integer::Planar64Mat3::from_cols(
Planar64Vec3::int(5,0,1)/2,
Planar64Vec3::int(0,1,0)/2,
Planar64Vec3::int(-1,0,5)/2,

4
src/physics_worker.rs
View File

@ -1,6 +1,6 @@
use crate::integer::Time;
use crate::physics::{MouseState,PhysicsInputInstruction};
use crate::instruction::{TimedInstruction,InstructionConsumer};
use strafesnet_common::integer::Time;
use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
#[derive(Debug)]
pub enum InputInstruction {
MoveMouse(glam::IVec2),

2
src/primitives.rs
View File

@ -1,5 +1,5 @@
use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
use crate::integer::Planar64Vec3;
use strafesnet_common::integer::Planar64Vec3;
#[derive(Debug)]
pub enum Primitives{

2
src/settings.rs
View File

@ -1,4 +1,4 @@
use crate::integer::{Ratio64,Ratio64Vec2};
use strafesnet_common::integer::{Ratio64,Ratio64Vec2};
#[derive(Clone)]
struct Ratio{
ratio:f64,

5
src/setup.rs
View File

@ -1,5 +1,6 @@
use crate::instruction::TimedInstruction;
use crate::window::WindowInstruction;
use strafesnet_common::instruction::TimedInstruction;
use strafesnet_common::integer;
fn optional_features()->wgpu::Features{
wgpu::Features::TEXTURE_COMPRESSION_ASTC
@ -226,7 +227,7 @@ fn run_event_loop(
root_time:std::time::Instant
)->Result<(),winit::error::EventLoopError>{
event_loop.run(move |event,elwt|{
let time=crate::integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
// *control_flow=if cfg!(feature="metal-auto-capture"){
// winit::event_loop::ControlFlow::Exit
// }else{

7
src/window.rs
View File

@ -1,5 +1,6 @@
use crate::instruction::TimedInstruction;
use crate::physics_worker::InputInstruction;
use strafesnet_common::integer;
use strafesnet_common::instruction::TimedInstruction;
pub enum WindowInstruction{
Resize(winit::dpi::PhysicalSize<u32>),
@ -23,7 +24,7 @@ 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:crate::integer::Time,event: winit::event::WindowEvent) {
fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) {
match event {
winit::event::WindowEvent::DroppedFile(path)=>{
//blocking because it's simpler...
@ -121,7 +122,7 @@ impl WindowContext<'_>{
}
}
fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
match event {
winit::event::DeviceEvent::MouseMotion {
delta,//these (f64,f64) are integers on my machine

8
src/worker.rs
View File

@ -183,8 +183,8 @@ fn test_worker() {
// Send tasks to the worker
for _ in 0..5 {
let task = crate::instruction::TimedInstruction{
time:crate::integer::Time::ZERO,
let task = strafesnet_common::instruction::TimedInstruction{
time:strafesnet_common::integer::Time::ZERO,
instruction:crate::physics::PhysicsInstruction::StrafeTick,
};
worker.send(task).unwrap();
@ -197,8 +197,8 @@ fn test_worker() {
thread::sleep(std::time::Duration::from_millis(10));
// Send a new task
let task = crate::instruction::TimedInstruction{
time:crate::integer::Time::ZERO,
let task = strafesnet_common::instruction::TimedInstruction{
time:strafesnet_common::integer::Time::ZERO,
instruction:crate::physics::PhysicsInstruction::StrafeTick,
};
worker.send(task).unwrap();

40
src/zeroes.rs
View File

@ -1,40 +0,0 @@
//find roots of polynomials
use crate::integer::Planar64;
#[inline]
pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
if a2==Planar64::ZERO{
return zeroes1(a0, a1);
}
let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
if 0<radicand {
//start with f64 sqrt
//failure case: 2^63 < sqrt(2^127)
let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
//TODO: one or two newtons
//sort roots ascending and avoid taking the difference of large numbers
match (Planar64::ZERO<a2,Planar64::ZERO<a1){
(true, true )=>vec![(-a1-planar_radicand)/(a2*2),(a0*2)/(-a1-planar_radicand)],
(true, false)=>vec![(a0*2)/(-a1+planar_radicand),(-a1+planar_radicand)/(a2*2)],
(false,true )=>vec![(a0*2)/(-a1-planar_radicand),(-a1-planar_radicand)/(a2*2)],
(false,false)=>vec![(-a1+planar_radicand)/(a2*2),(a0*2)/(-a1+planar_radicand)],
}
} else if radicand==0 {
return vec![a1/(a2*-2)];
} else {
return vec![];
}
}
#[inline]
pub fn zeroes1(a0:Planar64,a1:Planar64) -> Vec<Planar64> {
if a1==Planar64::ZERO{
return vec![];
}else{
let q=((-a0.get() as i128)<<32)/(a1.get() as i128);
if i64::MIN as i128<=q&&q<=i64::MAX as i128{
return vec![Planar64::raw(q as i64)];
}else{
return vec![];
}
}
}