Compare commits

..

1 Commits

Author SHA1 Message Date
f1ac04a7db RenderType + ShaderResource 2024-01-10 16:24:36 -08:00
23 changed files with 3798 additions and 2852 deletions

778
Cargo.lock generated

File diff suppressed because it is too large Load Diff

View File

@ -9,7 +9,7 @@ edition = "2021"
bytemuck = { version = "1.13.1", features = ["derive"] } bytemuck = { version = "1.13.1", features = ["derive"] }
configparser = "3.0.2" configparser = "3.0.2"
ddsfile = "0.5.1" ddsfile = "0.5.1"
glam = "0.25.0" glam = "0.24.1"
lazy-regex = "3.0.2" lazy-regex = "3.0.2"
obj = "0.10.2" obj = "0.10.2"
parking_lot = "0.12.1" parking_lot = "0.12.1"
@ -18,11 +18,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.18.0"
vbsp = "0.5.0" winit = { version = "0.29.2", features = ["rwh_05"] }
vmdl = "0.1.1"
wgpu = "0.19.0"
winit = "0.29.2"
#[profile.release] #[profile.release]
#lto = true #lto = true

View File

@ -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.
* *

46
src/aabb.rs Normal file
View File

@ -0,0 +1,46 @@
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 Normal file
View File

@ -0,0 +1,123 @@
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,
}
}
}

View File

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

View File

@ -1,5 +1,4 @@
use std::borrow::Cow; use std::borrow::Cow;
use strafesnet_common::integer;
use wgpu::{util::DeviceExt,AstcBlock,AstcChannel}; use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture}; use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
@ -153,14 +152,11 @@ impl GraphicsState{
let mut texture_loading_threads=Vec::new(); let mut texture_loading_threads=Vec::new();
let num_textures=indexed_models.textures.len(); let num_textures=indexed_models.textures.len();
for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){ for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
let path=std::path::PathBuf::from(format!("textures/{}.dds",texture_id)); if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",texture_id))){
if let Ok(mut file) = std::fs::File::open(path.clone()){
double_map.insert(i as u32, texture_loading_threads.len() as u32); double_map.insert(i as u32, texture_loading_threads.len() as u32);
texture_loading_threads.push((texture_id,std::thread::spawn(move ||{ texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
ddsfile::Dds::read(&mut file).unwrap() ddsfile::Dds::read(&mut file).unwrap()
}))); })));
}else{
//println!("missing texture path={:?}",path);
} }
} }
@ -204,7 +200,6 @@ impl GraphicsState{
label: Some(format!("Texture{}",texture_id).as_str()), label: Some(format!("Texture{}",texture_id).as_str()),
view_formats: &[], view_formats: &[],
}, },
wgpu::util::TextureDataOrder::LayerMajor,
&image.data, &image.data,
); );
texture.create_view(&wgpu::TextureViewDescriptor { texture.create_view(&wgpu::TextureViewDescriptor {
@ -221,7 +216,7 @@ impl GraphicsState{
for model in indexed_models.models.into_iter(){ for model in indexed_models.models.into_iter(){
//convert ModelInstance into GraphicsModelInstance //convert ModelInstance into GraphicsModelInstance
let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{ let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
if instance.color.w==0.0&&!model.groups.iter().any(|g|g.texture.is_some()){ if instance.color.w==0.0{
None None
}else{ }else{
Some(GraphicsModelInstance{ Some(GraphicsModelInstance{
@ -702,7 +697,6 @@ impl GraphicsState{
label: Some("Skybox Texture"), label: Some("Skybox Texture"),
view_formats: &[], view_formats: &[],
}, },
wgpu::util::TextureDataOrder::LayerMajor,
&skybox_image.data, &skybox_image.data,
); );
@ -743,7 +737,6 @@ impl GraphicsState{
label: Some("Squid Texture"), label: Some("Squid Texture"),
view_formats: &[], view_formats: &[],
}, },
wgpu::util::TextureDataOrder::LayerMajor,
&image.data, &image.data,
); );
@ -834,7 +827,7 @@ impl GraphicsState{
}); });
let camera=GraphicsCamera::default(); let camera=GraphicsCamera::default();
let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,integer::Time::ZERO)); let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,crate::integer::Time::ZERO));
let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Camera"), label: Some("Camera"),
contents: bytemuck::cast_slice(&camera_uniforms), contents: bytemuck::cast_slice(&camera_uniforms),
@ -903,7 +896,7 @@ impl GraphicsState{
device:&wgpu::Device, device:&wgpu::Device,
queue:&wgpu::Queue, queue:&wgpu::Queue,
physics_output:crate::physics::PhysicsOutputState, physics_output:crate::physics::PhysicsOutputState,
predicted_time:integer::Time, predicted_time:crate::integer::Time,
mouse_pos:glam::IVec2, mouse_pos:glam::IVec2,
) { ) {
//TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input //TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input

View File

@ -1,7 +1,5 @@
use strafesnet_common::integer;
pub enum Instruction{ pub enum Instruction{
Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2), Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
//UpdateModel(crate::graphics::GraphicsModelUpdate), //UpdateModel(crate::graphics::GraphicsModelUpdate),
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings), Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
GenerateModels(crate::model::IndexedModelInstances), GenerateModels(crate::model::IndexedModelInstances),
@ -20,7 +18,7 @@ WorkerDescription{
pub fn new<'a>( pub fn new<'a>(
mut graphics:crate::graphics::GraphicsState, mut graphics:crate::graphics::GraphicsState,
mut config:wgpu::SurfaceConfiguration, mut config:wgpu::SurfaceConfiguration,
surface:wgpu::Surface<'a>, surface:wgpu::Surface,
device:wgpu::Device, device:wgpu::Device,
queue:wgpu::Queue, queue:wgpu::Queue,
)->crate::compat_worker::INWorker<'a,Instruction>{ )->crate::compat_worker::INWorker<'a,Instruction>{

53
src/instruction.rs Normal file
View File

@ -0,0 +1,53 @@
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 Normal file

File diff suppressed because it is too large Load Diff

View File

@ -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)
},
}
}

View File

@ -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 {

View File

@ -1,14 +1,16 @@
use strafesnet_common::integer; mod bvh;
mod aabb;
mod model; mod model;
mod setup; mod setup;
mod window; mod window;
mod worker; mod worker;
mod zeroes;
mod integer;
mod physics; mod physics;
mod graphics; mod graphics;
mod settings; mod settings;
mod primitives; mod primitives;
mod load_bsp; mod instruction;
mod load_roblox; mod load_roblox;
mod face_crawler; mod face_crawler;
mod compat_worker; mod compat_worker;
@ -44,7 +46,7 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
}, },
} }
}, },
b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(), //b"VBSP"=>Some(load_bsp::generate_indexed_models(input)),
//b"SNFM"=>Some(sniffer::generate_indexed_models(input)), //b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
//b"SNFB"=>Some(sniffer::load_bot(input)), //b"SNFB"=>Some(sniffer::load_bot(input)),
other=>{ other=>{
@ -114,5 +116,6 @@ pub fn default_models()->model::IndexedModelInstances{
} }
fn main(){ fn main(){
setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION"))); let context=setup::setup(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str());
context.start();//creates and runs a window context
} }

View File

@ -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)]
@ -11,8 +11,33 @@ pub struct IndexedVertex{
pub struct IndexedPolygon{ pub struct IndexedPolygon{
pub vertices:Vec<u32>, pub vertices:Vec<u32>,
} }
pub type TextureId=u32;
pub type ShaderId=u32;
pub enum ShaderResource{
Model,//pass in model attributes
Texture(TextureId),
Depth,//current draw depth
Normal,
BehindTexture,//what is drawn behind this pixel
}
pub enum RenderType{
NoTexture,//simply draw the vertex color or model color or something
Texture(TextureId),
Material{
texture:TextureId,
normal:TextureId,
},
//GUI,
Portal{
transform:glam::Mat4,
},
Shader{
id:ShaderId,
resources:Vec<ShaderResource>,
},
}
pub struct IndexedGroup{ pub struct IndexedGroup{
pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color pub texture:Option<u32>,//TODO: RenderType
pub polys:Vec<IndexedPolygon>, pub polys:Vec<IndexedPolygon>,
} }
pub struct IndexedModel{ pub struct IndexedModel{

View File

@ -1,6 +1,5 @@
use crate::integer::{Planar64,Planar64Vec3};
use std::borrow::{Borrow,Cow}; use std::borrow::{Borrow,Cow};
use strafesnet_common::zeroes;
use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)] #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
pub struct VertId(usize); pub struct VertId(usize);
@ -237,15 +236,15 @@ impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
pub struct TransformedMesh<'a>{ pub struct TransformedMesh<'a>{
mesh:&'a PhysicsMesh, mesh:&'a PhysicsMesh,
transform:&'a integer::Planar64Affine3, transform:&'a crate::integer::Planar64Affine3,
normal_transform:&'a integer::Planar64Mat3, normal_transform:&'a crate::integer::Planar64Mat3,
transform_det:Planar64, transform_det:Planar64,
} }
impl TransformedMesh<'_>{ impl TransformedMesh<'_>{
pub fn new<'a>( pub fn new<'a>(
mesh:&'a PhysicsMesh, mesh:&'a PhysicsMesh,
transform:&'a integer::Planar64Affine3, transform:&'a crate::integer::Planar64Affine3,
normal_transform:&'a integer::Planar64Mat3, normal_transform:&'a crate::integer::Planar64Mat3,
transform_det:Planar64, transform_det:Planar64,
)->TransformedMesh<'a>{ )->TransformedMesh<'a>{
TransformedMesh{ TransformedMesh{
@ -390,7 +389,7 @@ impl MinkowskiMesh<'_>{
let test_vert_id=edge_verts[directed_edge_id.parity() as usize]; let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
//test if it's closer //test if it's closer
let diff=point-self.vert(test_vert_id); let diff=point-self.vert(test_vert_id);
if zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{ if crate::zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
let distance_squared=diff.dot(diff); let distance_squared=diff.dot(diff);
if distance_squared<*best_distance_squared{ if distance_squared<*best_distance_squared{
best_transition=Transition::Vert(test_vert_id); best_transition=Transition::Vert(test_vert_id);
@ -408,7 +407,7 @@ impl MinkowskiMesh<'_>{
//is boundary uncrossable by a crawl from infinity //is boundary uncrossable by a crawl from infinity
//check if time of collision is outside Time::MIN..Time::MAX //check if time of collision is outside Time::MIN..Time::MAX
let d=edge_n.dot(diff); let d=edge_n.dot(diff);
if zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{ if crate::zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
//test the edge //test the edge
let edge_nn=edge_n.dot(edge_n); let edge_nn=edge_n.dot(edge_n);
if Planar64::ZERO<=d&&d<=edge_nn{ if Planar64::ZERO<=d&&d<=edge_nn{
@ -460,7 +459,7 @@ impl MinkowskiMesh<'_>{
let boundary_d=boundary_n.dot(delta_pos); let boundary_d=boundary_n.dot(delta_pos);
//check if time of collision is outside Time::MIN..Time::MAX //check if time of collision is outside Time::MIN..Time::MAX
//infinity_dir can always be treated as a velocity //infinity_dir can always be treated as a velocity
if (boundary_d)<=Planar64::ZERO&&zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{ if (boundary_d)<=Planar64::ZERO&&crate::zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
//both faces cannot pass this condition, return early if one does. //both faces cannot pass this condition, return early if one does.
return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id); return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
} }
@ -476,13 +475,13 @@ impl MinkowskiMesh<'_>{
infinity_body.velocity=dir; infinity_body.velocity=dir;
infinity_body.acceleration=Planar64Vec3::ZERO; infinity_body.acceleration=Planar64Vec3::ZERO;
//crawl in from negative infinity along a tangent line to get the closest fev //crawl in from negative infinity along a tangent line to get the closest fev
match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN,infinity_body.time){ match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,crate::integer::Time::MIN,infinity_body.time){
crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev), crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
crate::face_crawler::CrawlResult::Hit(_,_)=>None, crate::face_crawler::CrawlResult::Hit(_,_)=>None,
} }
}) })
} }
pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{ pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{ self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
//continue forwards along the body parabola //continue forwards along the body parabola
match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){ match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
@ -491,7 +490,7 @@ impl MinkowskiMesh<'_>{
} }
}) })
} }
pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{ pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
//create an extrapolated body at time_limit //create an extrapolated body at time_limit
let infinity_body=crate::physics::Body::new( let infinity_body=crate::physics::Body::new(
relative_body.extrapolated_position(time_limit), relative_body.extrapolated_position(time_limit),
@ -507,7 +506,7 @@ impl MinkowskiMesh<'_>{
} }
}) })
} }
pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,integer::Time)>{ 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)>{
//no algorithm needed, there is only one state and two cases (Edge,None) //no algorithm needed, there is only one state and two cases (Edge,None)
//determine when it passes an edge ("sliding off" case) //determine when it passes an edge ("sliding off" case)
let mut best_time=time_limit; let mut best_time=time_limit;
@ -520,8 +519,8 @@ impl MinkowskiMesh<'_>{
let verts=self.edge_verts(directed_edge_id.as_undirected()); let verts=self.edge_verts(directed_edge_id.as_undirected());
let d=n.dot(self.vert(verts[0])+self.vert(verts[1])); let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
//WARNING! d outside of *2 //WARNING! d outside of *2
for t in zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){ 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+integer::Time::from(t); let t=relative_body.time+crate::integer::Time::from(t);
if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{ if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
best_time=t; best_time=t;
best_edge=Some(directed_edge_id); best_edge=Some(directed_edge_id);

File diff suppressed because it is too large Load Diff

View File

@ -1,165 +1,133 @@
use crate::physics::{MouseState,PhysicsInputInstruction}; use crate::integer::Time;
use strafesnet_common::integer::Time; use crate::physics::{MouseState,PhysicsInputInstruction};
use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer}; use crate::instruction::{TimedInstruction,InstructionConsumer};
use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2}; #[derive(Debug)]
pub enum InputInstruction {
#[derive(Debug)] MoveMouse(glam::IVec2),
pub enum InputInstruction { MoveRight(bool),
MoveMouse(glam::IVec2), MoveUp(bool),
MoveRight(bool), MoveBack(bool),
MoveUp(bool), MoveLeft(bool),
MoveBack(bool), MoveDown(bool),
MoveLeft(bool), MoveForward(bool),
MoveDown(bool), Jump(bool),
MoveForward(bool), Zoom(bool),
Jump(bool), Reset,
Zoom(bool), }
Reset, pub enum Instruction{
} Input(InputInstruction),
pub enum Instruction{ Render,
Input(InputInstruction), Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
Render, GenerateModels(crate::model::IndexedModelInstances),
Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings), ClearModels,
GenerateModels(crate::model::IndexedModelInstances), //Graphics(crate::graphics_worker::Instruction),
ClearModels, }
//Graphics(crate::graphics_worker::Instruction),
} pub fn new(mut physics:crate::physics::PhysicsState,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
let mut mouse_blocking=true;
pub struct Speed{ let mut last_mouse_time=physics.next_mouse.time;
pub player_vel:Planar64Vec3, let mut timeline=std::collections::VecDeque::new();
pub time:Time 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{
impl std::ops::Neg for Speed{ &InputInstruction::MoveMouse(m)=>{
type Output=Self; if mouse_blocking{
fn neg(self)->Self::Output{ //tell the game state which is living in the past about its future
Self{ timeline.push_front(TimedInstruction{
player_vel:self.player_vel, time:last_mouse_time,
time:self.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
impl Speed{ timeline.push_front(TimedInstruction{
pub fn new(player_vel:Planar64Vec3,time:Time)->Self{ time:last_mouse_time,
Self{ instruction:PhysicsInputInstruction::ReplaceMouse(
player_vel, MouseState{time:last_mouse_time,pos:physics.next_mouse.pos},
time, MouseState{time:ins.time,pos:m}
} ),
} });
} //delay physics execution until we have an interpolation target
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>>{ mouse_blocking=true;
let mut mouse_blocking=true; }
let mut last_mouse_time=physics.next_mouse.time; last_mouse_time=ins.time;
let mut timeline=std::collections::VecDeque::new(); None
let mut next_velocity_print=std::time::Instant::now(); },
let mut player_vel = physics.body.velocity.length(); &InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{ &InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
if if let Some(phys_input)=match &ins.instruction{ &InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
Instruction::Input(input_instruction)=>match input_instruction{ &InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
&InputInstruction::MoveMouse(m)=>{ &InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
if mouse_blocking{ &InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
//tell the game state which is living in the past about its future &InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
timeline.push_front(TimedInstruction{ &InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
time:last_mouse_time, InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:m}), },
}); Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
}else{ Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
//mouse has just started moving again after being still for longer than 10ms. Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero Instruction::Render=>Some(PhysicsInputInstruction::Idle),
timeline.push_front(TimedInstruction{ }{
time:last_mouse_time, //non-mouse event
instruction:PhysicsInputInstruction::ReplaceMouse( timeline.push_back(TimedInstruction{
MouseState{time:last_mouse_time,pos:physics.next_mouse.pos}, time:ins.time,
MouseState{time:ins.time,pos:m} instruction:phys_input,
), });
});
//delay physics execution until we have an interpolation target if mouse_blocking{
mouse_blocking=true; //assume the mouse has stopped moving after 10ms.
} //shitty mice are 125Hz which is 8ms so this should cover that.
last_mouse_time=ins.time; //setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
None //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{
&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)), //push an event to extrapolate no movement from
&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)), timeline.push_front(TimedInstruction{
&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)), time:last_mouse_time,
&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)), instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}),
&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)), });
&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)), last_mouse_time=ins.time;
&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)), //stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)), mouse_blocking=false;
InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset), true
}, }else{
Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle), false
Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle), }
Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle), }else{
Instruction::Render=>Some(PhysicsInputInstruction::Idle), //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
//non-mouse event last_mouse_time=ins.time;
timeline.push_back(TimedInstruction{ true
time:ins.time, }
instruction:phys_input, }else{
}); //mouse event
true
if mouse_blocking{ }{
//assume the mouse has stopped moving after 10ms. //empty queue
//shitty mice are 125Hz which is 8ms so this should cover that. while let Some(instruction)=timeline.pop_front(){
//setting this to 100us still doesn't print even though it's 10x lower than the polling rate, physics.run(instruction.time);
//so mouse events are probably not handled separately from drawing and fire right before it :( physics.process_instruction(TimedInstruction{
if Time::from_millis(10)<ins.time-physics.next_mouse.time{ time:instruction.time,
//push an event to extrapolate no movement from instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
timeline.push_front(TimedInstruction{ });
time:last_mouse_time, }
instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}), }
}); match ins.instruction{
last_mouse_time=ins.time; Instruction::Render=>{
//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets. graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
mouse_blocking=false; },
true Instruction::Resize(size,user_settings)=>{
}else{ graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
false },
} Instruction::GenerateModels(indexed_model_instances)=>{
}else{ physics.generate_models(&indexed_model_instances);
//keep this up to date so that it can be used as a known-timestamp physics.spawn(indexed_model_instances.spawn_point);
//that the mouse was not moving when the mouse starts moving again graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
last_mouse_time=ins.time; },
true Instruction::ClearModels=>{
} physics.clear();
}else{ graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
//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();
},
_=>(),
}
})
} }

View File

@ -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{

View File

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

View File

@ -1,6 +1,5 @@
use crate::instruction::TimedInstruction;
use crate::window::WindowInstruction; use crate::window::WindowInstruction;
use strafesnet_common::instruction::TimedInstruction;
use strafesnet_common::integer;
fn optional_features()->wgpu::Features{ fn optional_features()->wgpu::Features{
wgpu::Features::TEXTURE_COMPRESSION_ASTC wgpu::Features::TEXTURE_COMPRESSION_ASTC
@ -47,21 +46,21 @@ fn create_instance()->SetupContextPartial1{
} }
} }
impl SetupContextPartial1{ impl SetupContextPartial1{
fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{ fn create_surface(self,window:&winit::window::Window)->Result<SetupContextPartial2,wgpu::CreateSurfaceError>{
Ok(SetupContextPartial2{ Ok(SetupContextPartial2{
backends:self.backends, backends:self.backends,
surface:self.instance.create_surface(window)?, surface:unsafe{self.instance.create_surface(window)}?,
instance:self.instance, instance:self.instance,
}) })
} }
} }
struct SetupContextPartial2<'a>{ struct SetupContextPartial2{
backends:wgpu::Backends, backends:wgpu::Backends,
instance:wgpu::Instance, instance:wgpu::Instance,
surface:wgpu::Surface<'a>, surface:wgpu::Surface,
} }
impl<'a> SetupContextPartial2<'a>{ impl SetupContextPartial2{
fn pick_adapter(self)->SetupContextPartial3<'a>{ fn pick_adapter(self)->SetupContextPartial3{
let adapter; let adapter;
//TODO: prefer adapter that implements optional features //TODO: prefer adapter that implements optional features
@ -123,13 +122,13 @@ impl<'a> SetupContextPartial2<'a>{
} }
} }
} }
struct SetupContextPartial3<'a>{ struct SetupContextPartial3{
instance:wgpu::Instance, instance:wgpu::Instance,
surface:wgpu::Surface<'a>, surface:wgpu::Surface,
adapter:wgpu::Adapter, adapter:wgpu::Adapter,
} }
impl<'a> SetupContextPartial3<'a>{ impl SetupContextPartial3{
fn request_device(self)->SetupContextPartial4<'a>{ fn request_device(self)->SetupContextPartial4{
let optional_features=optional_features(); let optional_features=optional_features();
let required_features=required_features(); let required_features=required_features();
@ -141,8 +140,8 @@ impl<'a> SetupContextPartial3<'a>{
.request_device( .request_device(
&wgpu::DeviceDescriptor { &wgpu::DeviceDescriptor {
label: None, label: None,
required_features: (optional_features & self.adapter.features()) | required_features, features: (optional_features & self.adapter.features()) | required_features,
required_limits: needed_limits, limits: needed_limits,
}, },
trace_dir.ok().as_ref().map(std::path::Path::new), trace_dir.ok().as_ref().map(std::path::Path::new),
)) ))
@ -157,15 +156,15 @@ impl<'a> SetupContextPartial3<'a>{
} }
} }
} }
struct SetupContextPartial4<'a>{ struct SetupContextPartial4{
instance:wgpu::Instance, instance:wgpu::Instance,
surface:wgpu::Surface<'a>, surface:wgpu::Surface,
adapter:wgpu::Adapter, adapter:wgpu::Adapter,
device:wgpu::Device, device:wgpu::Device,
queue:wgpu::Queue, queue:wgpu::Queue,
} }
impl<'a> SetupContextPartial4<'a>{ impl SetupContextPartial4{
fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{ fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->SetupContext{
let mut config=self.surface let mut config=self.surface
.get_default_config(&self.adapter, size.width, size.height) .get_default_config(&self.adapter, size.width, size.height)
.expect("Surface isn't supported by the adapter."); .expect("Surface isn't supported by the adapter.");
@ -183,42 +182,65 @@ impl<'a> SetupContextPartial4<'a>{
} }
} }
} }
pub struct SetupContext<'a>{ pub struct SetupContext{
pub instance:wgpu::Instance, pub instance:wgpu::Instance,
pub surface:wgpu::Surface<'a>, pub surface:wgpu::Surface,
pub device:wgpu::Device, pub device:wgpu::Device,
pub queue:wgpu::Queue, pub queue:wgpu::Queue,
pub config:wgpu::SurfaceConfiguration, pub config:wgpu::SurfaceConfiguration,
} }
pub fn setup_and_start(title:String){ pub fn setup(title:&str)->SetupContextSetup{
let event_loop=winit::event_loop::EventLoop::new().unwrap(); let event_loop=winit::event_loop::EventLoop::new().unwrap();
let window=create_window(title,&event_loop).unwrap();
println!("Initializing the surface..."); println!("Initializing the surface...");
let partial_1=create_instance(); let partial_1=create_instance();
let window=create_window(title.as_str(),&event_loop).unwrap();
let partial_2=partial_1.create_surface(&window).unwrap(); let partial_2=partial_1.create_surface(&window).unwrap();
let partial_3=partial_2.pick_adapter(); let partial_3=partial_2.pick_adapter();
let partial_4=partial_3.request_device(); let partial_4=partial_3.request_device();
let size=window.inner_size(); SetupContextSetup{
window,
event_loop,
partial_context:partial_4,
}
}
let setup_context=partial_4.configure_surface(&size); pub struct SetupContextSetup{
window:winit::window::Window,
event_loop:winit::event_loop::EventLoop<()>,
partial_context:SetupContextPartial4,
}
//dedicated thread to ping request redraw back and resize the window doesn't seem logical impl SetupContextSetup{
fn into_split(self)->(winit::window::Window,winit::event_loop::EventLoop<()>,SetupContext){
let size=self.window.inner_size();
//Steal values and drop self
(
self.window,
self.event_loop,
self.partial_context.configure_surface(&size),
)
}
pub fn start(self){
let (window,event_loop,setup_context)=self.into_split();
let window=crate::window::WindowContextSetup::new(&setup_context,&window); //dedicated thread to ping request redraw back and resize the window doesn't seem logical
//the thread that spawns the physics thread
let window_thread=window.into_worker(setup_context);
println!("Entering event loop..."); let window=crate::window::WindowContextSetup::new(&setup_context,window);
let root_time=std::time::Instant::now(); //the thread that spawns the physics thread
run_event_loop(event_loop,window_thread,root_time).unwrap(); 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( fn run_event_loop(
@ -227,7 +249,7 @@ fn run_event_loop(
root_time:std::time::Instant root_time:std::time::Instant
)->Result<(),winit::error::EventLoopError>{ )->Result<(),winit::error::EventLoopError>{
event_loop.run(move |event,elwt|{ event_loop.run(move |event,elwt|{
let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64); let time=crate::integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
// *control_flow=if cfg!(feature="metal-auto-capture"){ // *control_flow=if cfg!(feature="metal-auto-capture"){
// winit::event_loop::ControlFlow::Exit // winit::event_loop::ControlFlow::Exit
// }else{ // }else{

View File

@ -1,6 +1,5 @@
use crate::instruction::TimedInstruction;
use crate::physics_worker::InputInstruction; use crate::physics_worker::InputInstruction;
use strafesnet_common::integer;
use strafesnet_common::instruction::TimedInstruction;
pub enum WindowInstruction{ pub enum WindowInstruction{
Resize(winit::dpi::PhysicalSize<u32>), Resize(winit::dpi::PhysicalSize<u32>),
@ -16,7 +15,7 @@ struct WindowContext<'a>{
mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>> mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
screen_size:glam::UVec2, screen_size:glam::UVec2,
user_settings:crate::settings::UserSettings, user_settings:crate::settings::UserSettings,
window:&'a winit::window::Window, window:winit::window::Window,
physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>, physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
} }
@ -24,7 +23,7 @@ impl WindowContext<'_>{
fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{ fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0) winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0)
} }
fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) { fn window_event(&mut self,time:crate::integer::Time,event: winit::event::WindowEvent) {
match event { match event {
winit::event::WindowEvent::DroppedFile(path)=>{ winit::event::WindowEvent::DroppedFile(path)=>{
//blocking because it's simpler... //blocking because it's simpler...
@ -122,7 +121,7 @@ impl WindowContext<'_>{
} }
} }
fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) { fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
match event { match event {
winit::event::DeviceEvent::MouseMotion { winit::event::DeviceEvent::MouseMotion {
delta,//these (f64,f64) are integers on my machine delta,//these (f64,f64) are integers on my machine
@ -159,15 +158,15 @@ impl WindowContext<'_>{
} }
} }
pub struct WindowContextSetup<'a>{ pub struct WindowContextSetup{
user_settings:crate::settings::UserSettings, user_settings:crate::settings::UserSettings,
window:&'a winit::window::Window, window:winit::window::Window,
physics:crate::physics::PhysicsState, physics:crate::physics::PhysicsState,
graphics:crate::graphics::GraphicsState, graphics:crate::graphics::GraphicsState,
} }
impl<'a> WindowContextSetup<'a>{ impl WindowContextSetup{
pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{ pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
//wee //wee
let user_settings=crate::settings::read_user_settings(); let user_settings=crate::settings::read_user_settings();
@ -195,7 +194,7 @@ impl<'a> WindowContextSetup<'a>{
} }
} }
fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{ fn into_context<'a>(self,setup_context:crate::setup::SetupContext)->WindowContext<'a>{
let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height); let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue); let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
WindowContext{ WindowContext{
@ -209,7 +208,7 @@ impl<'a> WindowContextSetup<'a>{
} }
} }
pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{ pub fn into_worker<'a>(self,setup_context:crate::setup::SetupContext)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
let mut window_context=self.into_context(setup_context); let mut window_context=self.into_context(setup_context);
crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{ crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
match ins.instruction{ match ins.instruction{

View File

@ -183,8 +183,8 @@ fn test_worker() {
// 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();
@ -197,8 +197,8 @@ fn test_worker() {
thread::sleep(std::time::Duration::from_millis(10)); thread::sleep(std::time::Duration::from_millis(10));
// Send a new task // Send a new task
let task = 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();

40
src/zeroes.rs Normal file
View File

@ -0,0 +1,40 @@
//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![];
}
}
}