todo

.cargo/config.toml

@@ -0,0 +1,2 @@
+[registries.strafesnet]
+index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"

.gitignore

@@ -1,2 +1 @@
 /target
-/textures

Cargo.toml

@@ -1,26 +1,36 @@
 [package]
 name = "strafe-client"
-version = "0.9.4"
+version = "0.10.1"
 edition = "2021"
+repository = "https://git.itzana.me/StrafesNET/strafe-client"
+license = "Custom"
+description = "StrafesNET game client for bhop and surf."
+authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = ["snf"]
+snf = ["dep:strafesnet_snf"]
+source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
+roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
 bytemuck = { version = "1.13.1", features = ["derive"] }
 configparser = "3.0.2"
 ddsfile = "0.5.1"
-glam = "0.25.0"
-id = { git = "https://git.itzana.me/Quaternions/id", rev = "1f710976cc786c8853dab73d6e1cee53158deeb0" }
+glam = "0.28.0"
+id = { version = "0.1.0", registry = "strafesnet" }
 parking_lot = "0.12.1"
 pollster = "0.3.0"
-strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "093a54c527134ef7020a22a0f5778df8cba60228" }
-strafesnet_bsp_loader = { git = "https://git.itzana.me/StrafesNET/bsp_loader", rev = "671b86802179572af3385bbd90cbe3bb5b6401a2" }
-strafesnet_rbx_loader = { git = "https://git.itzana.me/StrafesNET/rbx_loader", rev = "e0739fa792ad506e210f076b90697194005bb7de" }
-strafesnet_deferred_loader = { git = "https://git.itzana.me/StrafesNET/deferred_loader", rev = "c03cd0e905daf70b03b60b3e12509f96ee94a658", features = ["legacy"] }
-wgpu = "0.19.0"
-winit = "0.29.2"
+strafesnet_bsp_loader = { version = "0.1.3", registry = "strafesnet", optional = true }
+strafesnet_common = { version = "0.2.0", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.3.1", features = ["legacy"], registry = "strafesnet", optional = true }
+strafesnet_rbx_loader = { version = "0.3.2", registry = "strafesnet", optional = true }
+strafesnet_snf = { version = "0.1.0", registry = "strafesnet", optional = true }
+wgpu = "22.0.0"
+winit = "0.30.4"
 
-#[profile.release]
+[profile.release]
 #lto = true
-#strip = true
-#codegen-units = 1
+strip = true
+codegen-units = 1

src/file.rs

@@ -2,8 +2,14 @@ use std::io::Read;
 
 #[derive(Debug)]
 pub enum ReadError{
+	#[cfg(feature="roblox")]
 	Roblox(strafesnet_rbx_loader::ReadError),
+	#[cfg(feature="source")]
 	Source(strafesnet_bsp_loader::ReadError),
+	#[cfg(feature="snf")]
+	StrafesNET(strafesnet_snf::Error),
+	#[cfg(feature="snf")]
+	StrafesNETMap(strafesnet_snf::map::Error),
 	Io(std::io::Error),
 	UnknownFileFormat,
 }
@@ -15,16 +21,27 @@ impl std::fmt::Display for ReadError{
 impl std::error::Error for ReadError{}
 
 pub enum DataStructure{
+	#[cfg(feature="roblox")]
 	Roblox(strafesnet_rbx_loader::Dom),
-	Source(strafesnet_bsp_loader::Bsp)
+	#[cfg(feature="source")]
+	Source(strafesnet_bsp_loader::Bsp),
+	#[cfg(feature="snf")]
+	StrafesNET(strafesnet_common::map::CompleteMap),
 }
 
-pub fn read<R:Read>(input:R)->Result<DataStructure,ReadError>{
+pub fn read<R:Read+std::io::Seek>(input:R)->Result<DataStructure,ReadError>{
 	let mut buf=std::io::BufReader::new(input);
 	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
 	match &peek[0..4]{
+		#[cfg(feature="roblox")]
 		b"<rob"=>Ok(DataStructure::Roblox(strafesnet_rbx_loader::read(buf).map_err(ReadError::Roblox)?)),
+		#[cfg(feature="source")]
 		b"VBSP"=>Ok(DataStructure::Source(strafesnet_bsp_loader::read(buf).map_err(ReadError::Source)?)),
+		#[cfg(feature="snf")]
+		b"SNFM"=>Ok(DataStructure::StrafesNET(
+			strafesnet_snf::read_map(buf).map_err(ReadError::StrafesNET)?
+			.into_complete_map().map_err(ReadError::StrafesNETMap)?
+		)),
 		_=>Err(ReadError::UnknownFileFormat),
 	}
 }
@@ -46,17 +63,31 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
 	//blocking because it's simpler...
 	let file=std::fs::File::open(path).map_err(LoadError::File)?;
 	match read(file).map_err(LoadError::ReadError)?{
+		#[cfg(feature="snf")]
+		DataStructure::StrafesNET(map)=>Ok(map),
+		#[cfg(feature="roblox")]
 		DataStructure::Roblox(dom)=>{
 			let mut loader=strafesnet_deferred_loader::roblox_legacy();
 
+			let (texture_loader,mesh_loader)=loader.get_inner_mut();
+
 			let map_step1=strafesnet_rbx_loader::convert(
 				&dom,
-				|name|loader.acquire_render_config_id(name)
+				|name|texture_loader.acquire_render_config_id(name),
+				|name|mesh_loader.acquire_mesh_id(name),
+			);
+
+			let meshpart_meshes=mesh_loader.load_meshes().map_err(LoadError::Io)?;
+
+			let map_step2=map_step1.add_meshpart_meshes_and_calculate_attributes(
+				meshpart_meshes.into_iter().map(|(mesh_id,loader_model)|
+					(mesh_id,strafesnet_rbx_loader::data::RobloxMeshBytes::new(loader_model.get()))
+				)
 			);
 
 			let (textures,render_configs)=loader.into_render_configs().map_err(LoadError::Io)?.consume();
 
-			let map=map_step1.add_render_configs_and_textures(
+			let map=map_step2.add_render_configs_and_textures(
 				render_configs.into_iter(),
 				textures.into_iter().map(|(texture_id,texture)|
 					(texture_id,match texture{
@@ -67,6 +98,7 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
 
 			Ok(map)
 		},
+		#[cfg(feature="source")]
 		DataStructure::Source(bsp)=>{
 			let mut loader=strafesnet_deferred_loader::source_legacy();
 
@@ -74,9 +106,7 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
 
 			let map_step1=strafesnet_bsp_loader::convert(
 				&bsp,
-				//acquire_render_config_id
 				|name|texture_loader.acquire_render_config_id(name),
-				//acquire_mesh_id
 				|name|mesh_loader.acquire_mesh_id(name),
 			);
 
@@ -108,4 +138,4 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::Co
 			Ok(map)
 		},
 	}
-}
+}

src/graphics.rs

@@ -75,7 +75,7 @@ fn perspective_rh(fov_x_slope:f32,fov_y_slope:f32,z_near:f32,z_far:f32)->glam::M
 }
 impl GraphicsCamera{
 	pub fn proj(&self)->glam::Mat4{
-		perspective_rh(self.fov.x,self.fov.y,0.5,2000.0)
+		perspective_rh(self.fov.x,self.fov.y,0.4,4000.0)
 	}
 	pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
 		//f32 good enough for view matrix
@@ -151,7 +151,13 @@ impl GraphicsState{
 		//generate texture view per texture
 		let texture_views:HashMap<strafesnet_common::model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
-			let image=ddsfile::Dds::read(std::io::Cursor::new(texture_data)).ok()?;
+			let image=match ddsfile::Dds::read(std::io::Cursor::new(texture_data)){
+				Ok(image)=>image,
+				Err(e)=>{
+					println!("Error loading texture: {e}");
+					return None;
+				},
+			};
 
 			let (mut width,mut height)=(image.get_width(),image.get_height());
 
@@ -218,14 +224,8 @@ impl GraphicsState{
 				color:GraphicsModelColor4::new(model.color),
 			};
 			//get or create owned mesh map
-			if let Some(owned_mesh_map)=owned_mesh_id_from_mesh_id_render_config_id.get(&model.mesh){
-				//the mesh has already been split into a set of unique renderconfig meshes
-				//simply add one instance to each of them
-				for owned_mesh_id in owned_mesh_map.values(){
-					let owned_mesh=unique_render_config_models.get_mut(owned_mesh_id.get() as usize).unwrap();
-					owned_mesh.instances.push(instance.clone());
-				}
-			}else{
+			let owned_mesh_map=owned_mesh_id_from_mesh_id_render_config_id
+			.entry(model.mesh).or_insert_with(||{
 				let mut owned_mesh_map=HashMap::new();
 				//add mesh if renderid never before seen for this model
 				//add instance
@@ -233,17 +233,11 @@ impl GraphicsState{
 				//check each group, if it's using a new render config then make a new clone of the model
 				if let Some(mesh)=map.meshes.get(model.mesh.get() as usize){
 					for graphics_group in mesh.graphics_groups.iter(){
-						let render_config=&map.render_configs[graphics_group.render.get() as usize];
-						if model.color.w==0.0&&render_config.texture.is_none(){
-							continue;
-						}
 						//get or create owned mesh
-						let owned_mesh_id=if let Some(&owned_mesh_id)=owned_mesh_map.get(&graphics_group.render){
-							owned_mesh_id
-						}else{
+						let owned_mesh_id=owned_mesh_map
+						.entry(graphics_group.render).or_insert_with(||{
 							//create
 							let owned_mesh_id=IndexedGraphicsMeshOwnedRenderConfigId::new(unique_render_config_models.len() as u32);
-							owned_mesh_map.insert(graphics_group.render,owned_mesh_id);
 							unique_render_config_models.push(IndexedGraphicsMeshOwnedRenderConfig{
 								unique_pos:mesh.unique_pos.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
 								unique_tex:mesh.unique_tex.iter().map(|v|*v.as_ref()).collect(),
@@ -252,10 +246,10 @@ impl GraphicsState{
 								unique_vertices:mesh.unique_vertices.clone(),
 								render_config:graphics_group.render,
 								polys:model::PolygonGroup::PolygonList(model::PolygonList::new(Vec::new())),
-								instances:vec![instance.clone()],
+								instances:Vec::new(),
 							});
 							owned_mesh_id
-						};
+						});
 						let owned_mesh=unique_render_config_models.get_mut(owned_mesh_id.get() as usize).unwrap();
 						match &mut owned_mesh.polys{
 							model::PolygonGroup::PolygonList(polygon_list)=>polygon_list.extend(
@@ -269,8 +263,16 @@ impl GraphicsState{
 						}
 					}
 				}
-				owned_mesh_id_from_mesh_id_render_config_id.insert(model.mesh,owned_mesh_map);
-			};
+				owned_mesh_map
+			});
+			for owned_mesh_id in owned_mesh_map.values(){
+				let owned_mesh=unique_render_config_models.get_mut(owned_mesh_id.get() as usize).unwrap();
+				let render_config=&map.render_configs[owned_mesh.render_config.get() as usize];
+				if model.color.w==0.0&&render_config.texture.is_none(){
+					continue;
+				}
+				owned_mesh.instances.push(instance.clone());
+			}
 		}
 		//check every model to see if it's using the same (texture,color) but has few instances,if it is combine it into one model
 		//1. collect unique instances of texture and color,note model id
@@ -289,24 +291,14 @@ impl GraphicsState{
 				continue;
 			}
 			//populate hashmap
-			let unique_color=if let Some(unique_color)=unique_texture_color.get_mut(&model.render_config){
-				unique_color
-			}else{
-				//make new hashmap
-				let unique_color=HashMap::new();
-				unique_texture_color.insert(model.render_config,unique_color);
-				unique_texture_color.get_mut(&model.render_config).unwrap()
-			};
+			let unique_color=unique_texture_color
+			.entry(model.render_config)
+			.or_insert_with(||HashMap::new());
 			//separate instances by color
 			for (instance_id,instance) in model.instances.iter().enumerate(){
-				let model_instance_list=if let Some(model_instance_list)=unique_color.get_mut(&instance.color){
-					model_instance_list
-				}else{
-					//make new hashmap
-					let model_instance_list=Vec::new();
-					unique_color.insert(instance.color.clone(),model_instance_list);
-					unique_color.get_mut(&instance.color).unwrap()
-				};
+				let model_instance_list=unique_color
+				.entry(instance.color)
+				.or_insert_with(||Vec::new());
 				//add model instance to list
 				model_instance_list.push((model_id,instance_id));
 			}
@@ -342,46 +334,34 @@ impl GraphicsState{
 						let map_pos_id:Vec<PositionId>=model.unique_pos.iter().map(|untransformed_pos|{
 							let pos=instance.transform.transform_point3(glam::Vec3::from_array(untransformed_pos.clone())).to_array();
 							let h=bytemuck::cast::<[f32;3],[u32;3]>(pos);
-							PositionId::new((if let Some(&pos_id)=pos_id_from.get(&h){
-								pos_id
-							}else{
+							PositionId::new(*pos_id_from.entry(h).or_insert_with(||{
 								let pos_id=unique_pos.len();
 								unique_pos.push(pos);
-								pos_id_from.insert(h,pos_id);
 								pos_id
 							}) as u32)
 						}).collect();
 						let map_tex_id:Vec<TextureCoordinateId>=model.unique_tex.iter().map(|&tex|{
 							let h=bytemuck::cast::<[f32;2],[u32;2]>(tex);
-							TextureCoordinateId::new((if let Some(&tex_id)=tex_id_from.get(&h){
-								tex_id
-							}else{
+							TextureCoordinateId::new(*tex_id_from.entry(h).or_insert_with(||{
 								let tex_id=unique_tex.len();
 								unique_tex.push(tex);
-								tex_id_from.insert(h,tex_id);
 								tex_id
 							}) as u32)
 						}).collect();
 						let map_normal_id:Vec<NormalId>=model.unique_normal.iter().map(|untransformed_normal|{
 							let normal=(instance.normal_transform*glam::Vec3::from_array(untransformed_normal.clone())).to_array();
 							let h=bytemuck::cast::<[f32;3],[u32;3]>(normal);
-							NormalId::new((if let Some(&normal_id)=normal_id_from.get(&h){
-								normal_id
-							}else{
+							NormalId::new(*normal_id_from.entry(h).or_insert_with(||{
 								let normal_id=unique_normal.len();
 								unique_normal.push(normal);
-								normal_id_from.insert(h,normal_id);
 								normal_id
 							}) as u32)
 						}).collect();
 						let map_color_id:Vec<ColorId>=model.unique_color.iter().map(|&color|{
 							let h=bytemuck::cast::<[f32;4],[u32;4]>(color);
-							ColorId::new((if let Some(&color_id)=color_id_from.get(&h){
-								color_id
-							}else{
+							ColorId::new(*color_id_from.entry(h).or_insert_with(||{
 								let color_id=unique_color.len();
 								unique_color.push(color);
-								color_id_from.insert(h,color_id);
 								color_id
 							}) as u32)
 						}).collect();
@@ -394,12 +374,9 @@ impl GraphicsState{
 								normal:map_normal_id[unmapped_vertex.normal.get() as usize],
 								color:map_color_id[unmapped_vertex.color.get() as usize],
 							};
-							VertexId::new((if let Some(&vertex_id)=vertex_id_from.get(&vertex){
-								vertex_id
-							}else{
+							VertexId::new(*vertex_id_from.entry(vertex.clone()).or_insert_with(||{
 								let vertex_id=unique_vertices.len();
-								unique_vertices.push(vertex.clone());
-								vertex_id_from.insert(vertex,vertex_id);
+								unique_vertices.push(vertex);
 								vertex_id
 							}) as u32)
 						}).collect();
@@ -442,25 +419,26 @@ impl GraphicsState{
 			//this mut be combined in a more complex way if the models use different render patterns per group
 			let mut indices=Vec::new();
 			for poly in model.polys.polys(){
-				for end_index in 2..poly.len(){
-					for index in [0,end_index-1,end_index]{
-						let vertex_index=poly[index];
-						if let Some(&i)=index_from_vertex.get(&vertex_index){
-							indices.push(i);
-						}else{
-							let i=vertices.len();
-							let vertex=&model.unique_vertices[vertex_index.get() as usize];
-							vertices.push(GraphicsVertex{
-								pos:model.unique_pos[vertex.pos.get() as usize],
-								tex:model.unique_tex[vertex.tex.get() as usize],
-								normal:model.unique_normal[vertex.normal.get() as usize],
-								color:model.unique_color[vertex.color.get() as usize],
-							});
-							index_from_vertex.insert(vertex_index,i);
-							indices.push(i);
-						}
-					}
-				}
+				let mut poly_vertices=poly.iter()
+				.map(|&vertex_index|*index_from_vertex.entry(vertex_index).or_insert_with(||{
+					let i=vertices.len();
+					let vertex=&model.unique_vertices[vertex_index.get() as usize];
+					vertices.push(GraphicsVertex{
+						pos:model.unique_pos[vertex.pos.get() as usize],
+						tex:model.unique_tex[vertex.tex.get() as usize],
+						normal:model.unique_normal[vertex.normal.get() as usize],
+						color:model.unique_color[vertex.color.get() as usize],
+					});
+					i
+				}));
+
+				let a=poly_vertices.next().unwrap();
+				let mut b=poly_vertices.next().unwrap();
+
+				poly_vertices.for_each(|c|{
+					indices.extend([a,b,c]);
+					b=c;
+				});
 			}
 			GraphicsMeshOwnedRenderConfig{
 				instances:model.instances,
@@ -485,7 +463,9 @@ impl GraphicsState{
 			instance_count+=model.instances.len();
 			for instances_chunk in model.instances.rchunks(chunk_size){
 				model_count+=1;
-				let model_uniforms=get_instances_buffer_data(instances_chunk);
+				let mut model_uniforms=get_instances_buffer_data(instances_chunk);
+				//TEMP: fill with zeroes to pass validation
+				model_uniforms.resize(MODEL_BUFFER_SIZE*512,0.0f32);
 				let model_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
 					label:Some(format!("Model{} Buf",model_count).as_str()),
 					contents:bytemuck::cast_slice(&model_uniforms),
@@ -776,11 +756,13 @@ impl GraphicsState{
 				module:&shader,
 				entry_point:"vs_sky",
 				buffers:&[],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			},
 			fragment:Some(wgpu::FragmentState{
 				module:&shader,
 				entry_point:"fs_sky",
 				targets:&[Some(config.view_formats[0].into())],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			}),
 			primitive:wgpu::PrimitiveState{
 				front_face:wgpu::FrontFace::Cw,
@@ -795,6 +777,7 @@ impl GraphicsState{
 			}),
 			multisample:wgpu::MultisampleState::default(),
 			multiview:None,
+			cache:None,
 		});
 		let model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
 			label:Some("Model Pipeline"),
@@ -807,11 +790,13 @@ impl GraphicsState{
 					step_mode:wgpu::VertexStepMode::Vertex,
 					attributes:&wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x3,3=>Float32x4],
 				}],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			},
 			fragment:Some(wgpu::FragmentState{
 				module:&shader,
 				entry_point:"fs_entity_texture",
 				targets:&[Some(config.view_formats[0].into())],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			}),
 			primitive:wgpu::PrimitiveState{
 				front_face:wgpu::FrontFace::Cw,
@@ -827,10 +812,11 @@ impl GraphicsState{
 			}),
 			multisample:wgpu::MultisampleState::default(),
 			multiview:None,
+			cache:None,
 		});
 
 		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(crate::physics::MouseState::default()));
 		let camera_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
 			label:Some("Camera"),
 			contents:bytemuck::cast_slice(&camera_uniforms),
@@ -907,7 +893,7 @@ impl GraphicsState{
 		let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
 
 		// update rotation
-		let camera_uniforms=self.camera.to_uniform_data(physics_output.extrapolate(mouse_pos,predicted_time));
+		let camera_uniforms=self.camera.to_uniform_data(physics_output.extrapolate(crate::physics::MouseState{pos:mouse_pos,time:predicted_time}));
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,

src/main.rs

@@ -1,4 +1,6 @@
+mod file;
 mod setup;
+mod timer;
 mod window;
 mod worker;
 mod physics;
@@ -11,8 +13,6 @@ mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
 
-mod file;
-
 fn main(){
 	setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
 }

src/model_physics.rs

@@ -137,22 +137,22 @@ impl PhysicsMesh{
 		//go go gadget debug print mesh
 		let data=PhysicsMeshData{
 			faces:vec![
-				Face{normal:Planar64Vec3::raw( 4294967296, 0, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:Planar64Vec3::raw( 0, 4294967296, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:Planar64Vec3::raw( 0, 0, 4294967296),dot:Planar64::raw(4294967296)},
-				Face{normal:Planar64Vec3::raw(-4294967296, 0, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:Planar64Vec3::raw( 0,-4294967296, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:Planar64Vec3::raw( 0, 0,-4294967296),dot:Planar64::raw(4294967296)}
+				Face{normal:Planar64Vec3::raw_xyz( 4294967296, 0, 0),dot:Planar64::raw(4294967296)},
+				Face{normal:Planar64Vec3::raw_xyz( 0, 4294967296, 0),dot:Planar64::raw(4294967296)},
+				Face{normal:Planar64Vec3::raw_xyz( 0, 0, 4294967296),dot:Planar64::raw(4294967296)},
+				Face{normal:Planar64Vec3::raw_xyz(-4294967296, 0, 0),dot:Planar64::raw(4294967296)},
+				Face{normal:Planar64Vec3::raw_xyz( 0,-4294967296, 0),dot:Planar64::raw(4294967296)},
+				Face{normal:Planar64Vec3::raw_xyz( 0, 0,-4294967296),dot:Planar64::raw(4294967296)}
 			],
 			verts:vec![
-				Vert(Planar64Vec3::raw( 4294967296,-4294967296,-4294967296)),
-				Vert(Planar64Vec3::raw( 4294967296, 4294967296,-4294967296)),
-				Vert(Planar64Vec3::raw( 4294967296, 4294967296, 4294967296)),
-				Vert(Planar64Vec3::raw( 4294967296,-4294967296, 4294967296)),
-				Vert(Planar64Vec3::raw(-4294967296, 4294967296,-4294967296)),
-				Vert(Planar64Vec3::raw(-4294967296, 4294967296, 4294967296)),
-				Vert(Planar64Vec3::raw(-4294967296,-4294967296, 4294967296)),
-				Vert(Planar64Vec3::raw(-4294967296,-4294967296,-4294967296))
+				Vert(Planar64Vec3::raw_xyz( 4294967296,-4294967296,-4294967296)),
+				Vert(Planar64Vec3::raw_xyz( 4294967296, 4294967296,-4294967296)),
+				Vert(Planar64Vec3::raw_xyz( 4294967296, 4294967296, 4294967296)),
+				Vert(Planar64Vec3::raw_xyz( 4294967296,-4294967296, 4294967296)),
+				Vert(Planar64Vec3::raw_xyz(-4294967296, 4294967296,-4294967296)),
+				Vert(Planar64Vec3::raw_xyz(-4294967296, 4294967296, 4294967296)),
+				Vert(Planar64Vec3::raw_xyz(-4294967296,-4294967296, 4294967296)),
+				Vert(Planar64Vec3::raw_xyz(-4294967296,-4294967296,-4294967296))
 			]
 		};
 		let mesh_topology=PhysicsMeshTopology{
@@ -167,17 +167,17 @@ impl PhysicsMesh{
 				FaceRefs{edges:vec![SubmeshDirectedEdgeId(4),SubmeshDirectedEdgeId(0),SubmeshDirectedEdgeId((9223372036854775819u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(9)]}
 			],
 			edge_topology:vec![
-				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(5)],verts:[SubmeshVertId(0),SubmeshVertId(1)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(1)],verts:[SubmeshVertId(1),SubmeshVertId(2)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(2)],verts:[SubmeshVertId(2),SubmeshVertId(3)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(0)],verts:[SubmeshVertId(0),SubmeshVertId(3)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(1),SubmeshFaceId(5)],verts:[SubmeshVertId(1),SubmeshVertId(4)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(1),SubmeshFaceId(3)],verts:[SubmeshVertId(4),SubmeshVertId(5)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(2),SubmeshFaceId(1)],verts:[SubmeshVertId(2),SubmeshVertId(5)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(2)],verts:[SubmeshVertId(3),SubmeshVertId(6)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(2),SubmeshFaceId(3)],verts:[SubmeshVertId(5),SubmeshVertId(6)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(3),SubmeshFaceId(5)],verts:[SubmeshVertId(4),SubmeshVertId(7)]}, 
-				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(3)],verts:[SubmeshVertId(6),SubmeshVertId(7)]}, 
+				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(5)],verts:[SubmeshVertId(0),SubmeshVertId(1)]},
+				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(1)],verts:[SubmeshVertId(1),SubmeshVertId(2)]},
+				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(2)],verts:[SubmeshVertId(2),SubmeshVertId(3)]},
+				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(0)],verts:[SubmeshVertId(0),SubmeshVertId(3)]},
+				EdgeRefs{faces:[SubmeshFaceId(1),SubmeshFaceId(5)],verts:[SubmeshVertId(1),SubmeshVertId(4)]},
+				EdgeRefs{faces:[SubmeshFaceId(1),SubmeshFaceId(3)],verts:[SubmeshVertId(4),SubmeshVertId(5)]},
+				EdgeRefs{faces:[SubmeshFaceId(2),SubmeshFaceId(1)],verts:[SubmeshVertId(2),SubmeshVertId(5)]},
+				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(2)],verts:[SubmeshVertId(3),SubmeshVertId(6)]},
+				EdgeRefs{faces:[SubmeshFaceId(2),SubmeshFaceId(3)],verts:[SubmeshVertId(5),SubmeshVertId(6)]},
+				EdgeRefs{faces:[SubmeshFaceId(3),SubmeshFaceId(5)],verts:[SubmeshVertId(4),SubmeshVertId(7)]},
+				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(3)],verts:[SubmeshVertId(6),SubmeshVertId(7)]},
 				EdgeRefs{faces:[SubmeshFaceId(5),SubmeshFaceId(4)],verts:[SubmeshVertId(0),SubmeshVertId(7)]}
 			],
 			vert_topology:vec![
@@ -284,6 +284,7 @@ impl EdgePool{
 #[derive(Debug)]
 pub enum PhysicsMeshError{
 	ZeroVertices,
+	NoPhysicsGroups,
 }
 impl std::fmt::Display for PhysicsMeshError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -404,7 +405,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 				faces,
 				verts,
 			},
-			complete_mesh:mesh_topologies.pop().unwrap(),
+			complete_mesh:mesh_topologies.pop().ok_or(PhysicsMeshError::NoPhysicsGroups)?,
 			submeshes:mesh_topologies,
 		})
 	}
@@ -960,4 +961,4 @@ fn test_is_empty_volume(){
 fn build_me_a_cube(){
 	let mesh=PhysicsMesh::unit_cube();
 	//println!("mesh={:?}",mesh);
-}
+}

src/physics_worker.rs

@@ -13,121 +13,193 @@ pub enum InputInstruction{
 	Jump(bool),
 	Zoom(bool),
 	Reset,
+	PracticeFly,
 }
 pub enum Instruction{
-	Input(InputInstruction),
+	Passthrough(PassthroughInstruction),
+	Interpolate(InputInstruction),
+}
+pub enum PassthroughInstruction{
 	Render,
 	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
 	GenerateModels(strafesnet_common::map::CompleteMap),
 	ClearModels,
 	//Graphics(crate::graphics_worker::Instruction),
 }
-
-	pub fn new(mut physics:crate::physics::PhysicsContext,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
-		let mut mouse_blocking=true;
-		let mut last_mouse_time=physics.state.next_mouse.time;
-		let mut timeline=std::collections::VecDeque::new();
-		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.state.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.state.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.state.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),
+pub struct MouseInterpolator{
+	queue:std::collections::VecDeque<TimedInstruction<InputInstruction>>,
+}
+fn drain_queue(physics:&mut crate::physics::PhysicsContext,iterable:impl IntoIterator<Item=TimedInstruction<InputInstruction>>){
+	for ins in iterable{
+		let physics_input=match &ins.instruction{
+			InputInstruction::MoveMouse(_)=>panic!("Queue was confirmed to contain no MoveMouse events1"),
+			&InputInstruction::MoveForward(s)=>PhysicsInputInstruction::SetMoveForward(s),
+			&InputInstruction::MoveLeft(s)=>PhysicsInputInstruction::SetMoveLeft(s),
+			&InputInstruction::MoveBack(s)=>PhysicsInputInstruction::SetMoveBack(s),
+			&InputInstruction::MoveRight(s)=>PhysicsInputInstruction::SetMoveRight(s),
+			&InputInstruction::MoveUp(s)=>PhysicsInputInstruction::SetMoveUp(s),
+			&InputInstruction::MoveDown(s)=>PhysicsInputInstruction::SetMoveDown(s),
+			&InputInstruction::Jump(s)=>PhysicsInputInstruction::SetJump(s),
+			&InputInstruction::Zoom(s)=>PhysicsInputInstruction::SetZoom(s),
+			InputInstruction::Reset=>PhysicsInputInstruction::Reset,
+			InputInstruction::PracticeFly=>PhysicsInputInstruction::PracticeFly,
+		};
+		physics.run_input_instruction(TimedInstruction{
+			time:ins.time,
+			instruction:physics_input,
+		});
+	}
+}
+impl MouseInterpolator{
+	fn handle_instruction(&mut self,physics:&mut crate::physics::PhysicsContext,ins:TimedInstruction<InputInstruction>){
+		//need to handle the case where mouse polling rate is less than 100hz
+		//also the whole thing is probably wrong lol
+		let is_inserting_mouse_instruction=matches!(ins.instruction,InputInstruction::MoveMouse(_));
+		self.queue.push_back(ins);
+		//We just pushed an element.
+		//The first element is guaranteed to exist.
+		let mut iter=self.queue.iter();
+		//find a mouse input
+		'outer:loop{
+			match iter.next(){
+				Some(ins0)=>{
+					let physics_input=match &ins0.instruction{
+						&InputInstruction::MoveMouse(mut mouse0)=>{
+							//mouse instruction found.
+							//enter a new loop with different behaviour
+							//we have to wait for the next mouse event
+							//so there is a before and after interpolation target
+							//write down ins0.time to appease the borrow checker
+							let mut t0=ins0.time;
+							'inner:loop{
+								match iter.next(){
+									Some(ins1)=>match &ins1.instruction{
+										&InputInstruction::MoveMouse(mouse1)=>{
+											//we found two mouse events to interpolate between
+											let consume_count=self.queue.len()-iter.len()-1;//don't consume the mouse1 instruction
+											//fire off a mouse instruction
+											physics.run_input_instruction(TimedInstruction{
+												time:t0,
+												instruction:PhysicsInputInstruction::SetNextMouse(
+													MouseState{time:ins1.time,pos:mouse1}
+												),
+											});
+											//update inner loop state
+											mouse0=mouse1;
+											t0=ins1.time;
+											//drain and handle the elements from the front
+											std::mem::drop(iter);
+											let mut hot_queue=self.queue.drain(0..consume_count);
+											hot_queue.next();
+											drain_queue(physics,hot_queue);
+											iter=self.queue.iter();
+											//keep looking for another mouse instruction in the inner loop
+											continue 'inner;
+										},
+										_=>if Time::from_millis(10)<ins1.time-t0{
+											//we have passed more than 10ms of instructions and have not seen a mouse event.
+											let consume_count=self.queue.len()-iter.len();
+											//run an event to extrapolate no movement from
+											let last_mouse=physics.get_next_mouse();
+											physics.run_input_instruction(TimedInstruction{
+												time:last_mouse.time,
+												instruction:PhysicsInputInstruction::SetNextMouse(
+													MouseState{time:ins1.time,pos:last_mouse.pos}
+												),
+											});
+											//drop the iterator so we can consume the queue up to this point
+											std::mem::drop(iter);
+											//consume queue up to the scanned point
+											let mut hot_queue=self.queue.drain(0..consume_count);
+											//the first element is always the last mouse instruction (last_mouse above)
+											hot_queue.next();
+											drain_queue(physics,hot_queue);
+											//make a new iterator starting from the new beginning
+											//and continue looping like nothing happened
+											iter=self.queue.iter();
+											continue 'outer;
+										},
+									},
+									None=>{
+										if is_inserting_mouse_instruction{
+											//the mouse started moving again after being still for over 10ms.
+											//replace the entire mouse state
+											physics.run_input_instruction(TimedInstruction{
+												time:physics.get_next_mouse().time,
+												instruction:PhysicsInputInstruction::ReplaceMouse(
+													physics.get_next_mouse().clone(),
+													MouseState{time:t0,pos:mouse0}
+												),
+											});
+										}
+										break 'outer;
+									}
+								}
+							}
+						},
+						&InputInstruction::MoveForward(s)=>PhysicsInputInstruction::SetMoveForward(s),
+						&InputInstruction::MoveLeft(s)=>PhysicsInputInstruction::SetMoveLeft(s),
+						&InputInstruction::MoveBack(s)=>PhysicsInputInstruction::SetMoveBack(s),
+						&InputInstruction::MoveRight(s)=>PhysicsInputInstruction::SetMoveRight(s),
+						&InputInstruction::MoveUp(s)=>PhysicsInputInstruction::SetMoveUp(s),
+						&InputInstruction::MoveDown(s)=>PhysicsInputInstruction::SetMoveDown(s),
+						&InputInstruction::Jump(s)=>PhysicsInputInstruction::SetJump(s),
+						&InputInstruction::Zoom(s)=>PhysicsInputInstruction::SetZoom(s),
+						InputInstruction::Reset=>PhysicsInputInstruction::Reset,
+						InputInstruction::PracticeFly=>PhysicsInputInstruction::PracticeFly,
+					};
+					//handle each event immediately, we are not waiting for mouse
+					physics.run_input_instruction(TimedInstruction{
+						time:ins0.time,
+						instruction:physics_input,
 					});
+					//drop it and pop it! consume one element and continue the loop
+					std::mem::drop(iter);
+					self.queue.pop_front();
+					iter=self.queue.iter();
+				},
+				None=>{
+					//if mouse0 is never found and the loop ends, we can drain the entire queue
+					//because we are not waiting for mouse events.
+					drain_queue(physics,self.queue.drain(..));
+					break 'outer;
 				}
 			}
-			match ins.instruction{
-				Instruction::Render=>{
-					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.state.output(),ins.time,physics.state.next_mouse.pos)).unwrap();
-				},
-				Instruction::Resize(size,user_settings)=>{
-					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
-				},
-				Instruction::GenerateModels(map)=>{
-					physics.generate_models(&map);
-					physics.spawn();
-					graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(map)).unwrap();
-				},
-				Instruction::ClearModels=>{
-					physics.state.clear();
-					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
-				},
-				_=>(),
-			}
-		})
-	}
+		}
+	}
+}
+
+pub fn new(mut physics:crate::physics::PhysicsContext,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
+	let mut interpolator=MouseInterpolator{
+		queue:std::collections::VecDeque::new(),
+	};
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+		let passthrough_instruction=match ins.instruction{
+			Instruction::Passthrough(passthrough_instruction)=>passthrough_instruction,
+			Instruction::Interpolate(input_instruction)=>{
+				interpolator.handle_instruction(&mut physics,TimedInstruction{
+					instruction:input_instruction,
+					time:ins.time,
+				});
+				return;
+			},
+		};
+		match passthrough_instruction{
+			PassthroughInstruction::Render=>{
+				graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.get_next_mouse().pos)).unwrap();
+			},
+			PassthroughInstruction::Resize(size,user_settings)=>{
+				graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
+			},
+			PassthroughInstruction::GenerateModels(map)=>{
+				physics.generate_models(&map);
+				physics.spawn();
+				graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(map)).unwrap();
+			},
+			PassthroughInstruction::ClearModels=>{
+				physics.clear();
+				graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
+			},
+		}
+	})
+}

src/setup.rs

@@ -25,14 +25,14 @@ struct SetupContextPartial1{
 	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);
+	let mut attr=winit::window::WindowAttributes::default();
+	attr=attr.with_title(title);
 	#[cfg(windows_OFF)] // TODO
 	{
 		use winit::platform::windows::WindowBuilderExtWindows;
-		builder = builder.with_no_redirection_bitmap(true);
+		builder=builder.with_no_redirection_bitmap(true);
 	}
-	builder.build(event_loop)
+	event_loop.create_window(attr)
 }
 fn create_instance()->SetupContextPartial1{
 	let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
@@ -143,6 +143,7 @@ impl<'a> SetupContextPartial3<'a>{
 					label: None,
 					required_features: (optional_features & self.adapter.features()) | required_features,
 					required_limits: needed_limits,
+					memory_hints:wgpu::MemoryHints::Performance,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
@@ -287,4 +288,4 @@ fn run_event_loop(
 				_=>{}
 			}
 		})
-}
+}

src/shader.wgsl

@@ -48,7 +48,7 @@ struct ModelInstance{
 //my fancy idea is to create a megatexture for each model that includes all the textures each intance will need
 //the texture transform then maps the texture coordinates to the location of the specific texture
 //group 1 is the model
-const MAX_MODEL_INSTANCES=4096;
+const MAX_MODEL_INSTANCES=512;
 @group(2)
 @binding(0)
 var<uniform> model_instances: array<ModelInstance, MAX_MODEL_INSTANCES>;

src/timer.rs

@@ -0,0 +1,179 @@
+use strafesnet_common::integer::{Time,Ratio64};
+
+pub trait TimerState:Copy{
+	fn get_time(&self,time:Time)->Time;
+	fn set_time(&mut self,time:Time,new_time:Time);
+	fn get_offset(&self)->Time;
+	fn set_offset(&mut self,offset:Time);
+}
+
+#[derive(Clone,Copy,Debug)]
+struct Scaled{
+	scale:Ratio64,
+	offset:Time,
+}
+impl Scaled{
+	fn scale(&self,time:Time)->Time{
+		Time::raw(self.scale.mul_int(time.get()))
+	}
+	fn get_scale(&self)->Ratio64{
+		self.scale
+	}
+	fn set_scale(&mut self,time:Time,new_scale:Ratio64){
+		let new_time=self.get_time(time);
+		self.scale=new_scale;
+		self.set_time(time,new_time);
+	}
+}
+impl TimerState for Scaled{
+	fn get_time(&self,time:Time)->Time{
+		self.scale(time)+self.offset
+	}
+	fn set_time(&mut self,time:Time,new_time:Time){
+		self.offset=new_time-self.scale(time);
+	}
+	fn get_offset(&self)->Time{
+		self.offset
+	}
+	fn set_offset(&mut self,offset:Time){
+		self.offset=offset;
+	}
+}
+
+#[derive(Clone,Copy,Debug)]
+struct Realtime{
+	offset:Time,
+}
+impl TimerState for Realtime{
+	fn get_time(&self,time:Time)->Time{
+		time+self.offset
+	}
+	fn set_time(&mut self,time:Time,new_time:Time){
+		self.offset=new_time-time;
+	}
+	fn get_offset(&self)->Time{
+		self.offset
+	}
+	fn set_offset(&mut self,offset:Time){
+		self.offset=offset;
+	}
+}
+
+#[derive(Clone,Debug)]
+pub struct Timer<T>{
+	state:T,
+	paused:bool,
+}
+
+impl Timer<Realtime>{
+	pub fn realtime(offset:Time)->Self{
+		Self{
+			state:Realtime{offset},
+			paused:false,
+		}
+	}
+	pub fn realtime_paused(offset:Time)->Self{
+		Self{
+			state:Realtime{offset},
+			paused:true,
+		}
+	}
+}
+
+#[derive(Debug)]
+pub enum Error{
+	AlreadyPaused,
+	AlreadyUnpaused,
+}
+impl std::fmt::Display for Error{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for Error{}
+
+impl Timer<Scaled>{
+	pub fn scaled(scale:Ratio64,offset:Time)->Self{
+		Self{
+			state:Scaled{scale,offset},
+			paused:false,
+		}
+	}
+	pub fn scaled_paused(scale:Ratio64,offset:Time)->Self{
+		Self{
+			state:Scaled{scale,offset},
+			paused:true,
+		}
+	}
+	pub fn get_scale(&mut self)->Ratio64{
+		self.state.get_scale()
+	}
+	pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
+		self.state.set_scale(time,new_scale)
+	}
+}
+
+impl<T:TimerState> Timer<T>{
+	pub fn time(&self,time:Time)->Time{
+		match self.paused{
+			true=>self.state.get_offset(),
+			false=>self.state.get_time(time),
+		}
+	}
+	pub fn set_time(&mut self,time:Time,new_time:Time){
+		match self.paused{
+			true=>self.state.set_offset(new_time),
+			false=>self.state.set_time(time,new_time),
+		}
+	}
+	pub fn pause(&mut self,time:Time)->Result<(),Error>{
+		match self.paused{
+			true=>Err(Error::AlreadyPaused),
+			false=>{
+				let new_time=self.time(time);
+				self.state.set_offset(new_time);
+				self.paused=true;
+				Ok(())
+			},
+		}
+	}
+	pub fn unpause(&mut self,time:Time)->Result<(),Error>{
+		match self.paused{
+			true=>{
+				let new_time=self.time(time);
+				self.state.set_time(time,new_time);
+				self.paused=false;
+				Ok(())
+			},
+			false=>Err(Error::AlreadyUnpaused),
+		}
+	}
+}
+#[cfg(test)]
+mod test{
+	use super::{Time,Timer,Error};
+	macro_rules! sec {
+		($s: expr) => {
+			Time::from_secs($s)
+		};
+	}
+	#[test]
+	fn test_timer()->Result<(),Error>{
+		//create a paused timer that reads 0s
+		let mut timer=Timer::realtime_paused(sec!(0));
+		//the paused timer at 1 second should read 0s
+		assert_eq!(timer.time(sec!(1)),sec!(0));
+
+		//unpause it after one second
+		timer.unpause(sec!(1))?;
+		//the timer at 6 seconds should read 5s
+		assert_eq!(timer.time(sec!(6)),sec!(5));
+
+		//pause the timer after 11 seconds
+		timer.pause(sec!(11))?;
+		//the paused timer at 20 seconds should read 10s
+		assert_eq!(timer.time(sec!(20)),sec!(10));
+
+		Ok(())
+	}
+}

src/window.rs

@@ -29,8 +29,12 @@ impl WindowContext<'_>{
 			winit::event::WindowEvent::DroppedFile(path)=>{
 				match crate::file::load(path.as_path()){
 					Ok(map)=>{
-						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(map)}).unwrap();
+						self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::Passthrough(
+							crate::physics_worker::PassthroughInstruction::ClearModels
+						)}).unwrap();
+						self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::Passthrough(
+							crate::physics_worker::PassthroughInstruction::GenerateModels(map)
+						)}).unwrap();
 					},
 					Err(e)=>println!("Failed to load map: {e}"),
 				}
@@ -108,13 +112,14 @@ impl WindowContext<'_>{
 								"q"=>Some(InputInstruction::MoveDown(s)),
 								"z"=>Some(InputInstruction::Zoom(s)),
 								"r"=>if s{Some(InputInstruction::Reset)}else{None},
+								"f"=>if s{Some(InputInstruction::PracticeFly)}else{None},
 								_=>None,
 							},
 							_=>None,
 						}{
 							self.physics_thread.send(TimedInstruction{
 								time,
-								instruction:crate::physics_worker::Instruction::Input(input_instruction),
+								instruction:crate::physics_worker::Instruction::Interpolate(input_instruction),
 							}).unwrap();
 						}
 					},
@@ -142,7 +147,7 @@ impl WindowContext<'_>{
 				self.mouse.pos+=delta;
 				self.physics_thread.send(TimedInstruction{
 					time,
-					instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
+					instruction:crate::physics_worker::Instruction::Interpolate(InputInstruction::MoveMouse(self.mouse.pos)),
 				}).unwrap();
 			},
 			winit::event::DeviceEvent::MouseWheel {
@@ -152,7 +157,7 @@ impl WindowContext<'_>{
 				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
+						instruction:crate::physics_worker::Instruction::Interpolate(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
 					}).unwrap();
 				}
 			}
@@ -173,7 +178,7 @@ impl<'a> WindowContextSetup<'a>{
 		let user_settings=crate::settings::read_user_settings();
 
 		let mut physics=crate::physics::PhysicsContext::default();
-		physics.state.load_user_settings(&user_settings);
+		physics.load_user_settings(&user_settings);
 
 		let mut graphics=crate::graphics::GraphicsState::new(&context.device,&context.queue,&context.config);
 		graphics.load_user_settings(&user_settings);
@@ -217,7 +222,9 @@ impl<'a> WindowContextSetup<'a>{
 					window_context.physics_thread.send(
 						TimedInstruction{
 							time:ins.time,
-							instruction:crate::physics_worker::Instruction::Resize(size,window_context.user_settings.clone())
+							instruction:crate::physics_worker::Instruction::Passthrough(
+								crate::physics_worker::PassthroughInstruction::Resize(size,window_context.user_settings.clone())
+							)
 						}
 					).unwrap();
 				}
@@ -225,11 +232,13 @@ impl<'a> WindowContextSetup<'a>{
 					window_context.physics_thread.send(
 						TimedInstruction{
 							time:ins.time,
-							instruction:crate::physics_worker::Instruction::Render
+							instruction:crate::physics_worker::Instruction::Passthrough(
+								crate::physics_worker::PassthroughInstruction::Render
+							)
 						}
 					).unwrap();
 				}
 			}
 		})
 	}
-}
+}

tools/arcane

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692113331.rbxm
+mangohud ../target/release/strafe-client bhop_maps/5692113331.snfm

tools/bhop_maps

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/maps/bhop_all/
+/run/media/quat/Files/Documents/map-files/verify-scripts/maps/bhop_snfm

tools/cross-compile.sh

@@ -1 +1 @@
-cargo build --release --target x86_64-pc-windows-gnu
+cargo build --release --target x86_64-pc-windows-gnu --all-features

tools/surf_maps

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/maps/surf_all/
+/run/media/quat/Files/Documents/map-files/verify-scripts/maps/surf_snfm

tools/textures

@@ -1 +0,0 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/textures/dds/

tools/toc

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692152916.rbxm
+mangohud ../target/release/strafe-client bhop_maps/5692152916.snfm

tools/utopia

@@ -1 +1 @@
-mangohud ../target/release/strafe-client surf_maps/5692145408.rbxm
+mangohud ../target/release/strafe-client surf_maps/5692145408.snfm