update rbx_loader

make invalid states unrepresentable!!!

.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,29 +1,36 @@
 [package]
 name = "strafe-client"
-version = "0.9.0"
+version = "0.10.5"
 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.24.1"
-lazy-regex = "3.0.2"
-obj = "0.10.2"
+glam = "0.29.0"
+id = { version = "0.1.0", registry = "strafesnet" }
 parking_lot = "0.12.1"
 pollster = "0.3.0"
-rbx_binary = "0.7.1"
-rbx_dom_weak = "2.5.0"
-rbx_reflection_database = "0.2.7"
-rbx_xml = "0.13.1"
-vbsp = "0.5.0"
-vmdl = "0.1.1"
-wgpu = "0.18.0"
-winit = { version = "0.29.2", features = ["rwh_05"] }
+strafesnet_bsp_loader = { version = "0.2.1", registry = "strafesnet", optional = true }
+strafesnet_common = { version = "0.5.2", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.4.0", features = ["legacy"], registry = "strafesnet", optional = true }
+strafesnet_rbx_loader = { version = "0.5.1", registry = "strafesnet", optional = true }
+strafesnet_snf = { version = "0.2.0", registry = "strafesnet", optional = true }
+wgpu = "22.1.0"
+winit = "0.30.5"
 
-#[profile.release]
+[profile.release]
 #lto = true
-#strip = true
-#codegen-units = 1
+strip = true
+codegen-units = 1

LICENSE

@@ -1,5 +1,5 @@
 /*******************************************************
-* Copyright (C) 2023 Rhys Lloyd <krakow20@gmail.com>
+* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
 *
 * This file is part of the StrafesNET bhop/surf client.
 *

src/aabb.rs

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

src/bvh.rs

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

src/face_crawler.rs

@@ -1,32 +1,33 @@
 use crate::physics::Body;
-use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
-use crate::integer::{Time,Planar64};
-use crate::zeroes::zeroes2;
+use crate::model_physics::{GigaTime,FEV,MeshQuery,DirectedEdge,MinkowskiMesh,MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert};
+use strafesnet_common::integer::{Time,Fixed,Ratio};
 
+#[derive(Debug)]
 enum Transition<F,E:DirectedEdge,V>{
 	Miss,
-	Next(FEV<F,E,V>,Time),
-	Hit(F,Time),
+	Next(FEV<F,E,V>,GigaTime),
+	Hit(F,GigaTime),
 }
 
-	fn next_transition<F:Copy,E:Copy+DirectedEdge,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
+type MinkowskiFEV=FEV<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
+type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
+
+	fn next_transition(fev:&MinkowskiFEV,body_time:GigaTime,mesh:&MinkowskiMesh,body:&Body,mut best_time:GigaTime)->MinkowskiTransition{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
-		let mut best_time=time_limit;
-		let mut best_transtition=Transition::Miss;
+		let mut best_transition=MinkowskiTransition::Miss;
 		match fev{
-			&FEV::<F,E,V>::Face(face_id)=>{
+			&MinkowskiFEV::Face(face_id)=>{
 				//test own face collision time, ignoring roots with zero or conflicting derivative
 				//n=face.normal d=face.dot
 				//n.a t^2+n.v t+n.p-d==0
 				let (n,d)=mesh.face_nd(face_id);
 				//TODO: use higher precision d value?
 				//use the mesh transform translation instead of baking it into the d value.
-				for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					let t=body.time+Time::from(t);
-					if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-						best_time=t;
-						best_transtition=Transition::Hit(face_id,t);
+				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+					if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						best_time=dt;
+						best_transition=MinkowskiTransition::Hit(face_id,dt);
 						break;
 					}
 				}
@@ -36,18 +37,18 @@ enum Transition<F,E:DirectedEdge,V>{
 					let n=n.cross(edge_n);
 					let verts=mesh.edge_verts(directed_edge_id.as_undirected());
 					//WARNING: d is moved out of the *2 block because of adding two vertices!
-					for t in zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))),n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
+					//WARNING: precision is swept under the rug!
+					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
+						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							best_time=dt;
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
 				}
 				//if none:
 			},
-			&FEV::<F,E,V>::Edge(edge_id)=>{
+			&MinkowskiFEV::Edge(edge_id)=>{
 				//test each face collision time, ignoring roots with zero or conflicting derivative
 				let edge_n=mesh.edge_n(edge_id);
 				let edge_verts=mesh.edge_verts(edge_id);
@@ -57,11 +58,10 @@ enum Transition<F,E:DirectedEdge,V>{
 					//edge_n gets parity from the order of edge_faces
 					let n=face_n.cross(edge_n)*((i as i64)*2-1);
 					//WARNING yada yada d *2
-					for t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
+					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
+						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							best_time=dt;
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Face(edge_face_id),dt);
 							break;
 						}
 					}
@@ -70,27 +70,27 @@ enum Transition<F,E:DirectedEdge,V>{
 				for (i,&vert_id) in edge_verts.iter().enumerate(){
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
-					for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
+					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
+							best_time=dt;
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Vert(vert_id),dt);
 							break;
 						}
 					}
 				}
 				//if none:
 			},
-			&FEV::<F,E,V>::Vert(vert_id)=>{
+			&MinkowskiFEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
 				for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					let n=-mesh.directed_edge_n(directed_edge_id);
-					for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
+					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
+							best_time=dt;
+							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
@@ -98,22 +98,30 @@ enum Transition<F,E:DirectedEdge,V>{
 				//if none:
 			},
 		}
-		best_transtition
+		best_transition
 	}
 pub enum CrawlResult<F,E:DirectedEdge,V>{
 	Miss(FEV<F,E,V>),
-	Hit(F,Time),
+	Hit(F,GigaTime),
 }
-pub fn crawl_fev<F:Copy,E:Copy+DirectedEdge,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>{	
-	let mut time=start_time;
+type MinkowskiCrawlResult=CrawlResult<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
+pub fn crawl_fev(mut fev:MinkowskiFEV,mesh:&MinkowskiMesh,relative_body:&Body,start_time:Time,time_limit:Time)->MinkowskiCrawlResult{
+	let mut body_time={
+		let r=(start_time-relative_body.time).to_ratio();
+		Ratio::new(r.num.fix_4(),r.den.fix_4())
+	};
+	let time_limit={
+		let r=(time_limit-relative_body.time).to_ratio();
+		Ratio::new(r.num.fix_4(),r.den.fix_4())
+	};
 	for _ in 0..20{
-		match next_transition(&fev,time,mesh,relative_body,time_limit){
+		match next_transition(&fev,body_time,mesh,relative_body,time_limit){
 			Transition::Miss=>return CrawlResult::Miss(fev),
-			Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
+			Transition::Next(next_fev,next_time)=>(fev,body_time)=(next_fev,next_time),
 			Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
 		}
 	}
 	//TODO: fix all bugs
-	println!("Too many iterations!  Using default behaviour instead of crashing...");
+	//println!("Too many iterations!  Using default behaviour instead of crashing...");
 	CrawlResult::Miss(fev)
 }

src/file.rs

@@ -0,0 +1,144 @@
+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,
+}
+impl std::fmt::Display for ReadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for ReadError{}
+
+pub enum DataStructure{
+	#[cfg(feature="roblox")]
+	Roblox(strafesnet_rbx_loader::Model),
+	#[cfg(feature="source")]
+	Source(strafesnet_bsp_loader::Bsp),
+	#[cfg(feature="snf")]
+	StrafesNET(strafesnet_common::map::CompleteMap),
+}
+
+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),
+	}
+}
+
+#[derive(Debug)]
+pub enum LoadError{
+	ReadError(ReadError),
+	File(std::io::Error),
+	Io(std::io::Error),
+}
+impl std::fmt::Display for LoadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadError{}
+
+pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	//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(model)=>{
+			let mut place=model.into_place();
+			place.run_scripts();
+
+			let mut loader=strafesnet_deferred_loader::roblox_legacy();
+
+			let (texture_loader,mesh_loader)=loader.get_inner_mut();
+
+			let map_step1=strafesnet_rbx_loader::convert(
+				&place,
+				|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_step2.add_render_configs_and_textures(
+				render_configs.into_iter(),
+				textures.into_iter().map(|(texture_id,texture)|
+					(texture_id,match texture{
+						strafesnet_deferred_loader::texture::Texture::ImageDDS(data)=>data,
+					})
+				)
+			);
+
+			Ok(map)
+		},
+		#[cfg(feature="source")]
+		DataStructure::Source(bsp)=>{
+			let mut loader=strafesnet_deferred_loader::source_legacy();
+
+			let (texture_loader,mesh_loader)=loader.get_inner_mut();
+
+			let map_step1=strafesnet_bsp_loader::convert(
+				&bsp,
+				|name|texture_loader.acquire_render_config_id(name),
+				|name|mesh_loader.acquire_mesh_id(name),
+			);
+
+			let prop_meshes=mesh_loader.load_meshes(bsp.as_ref());
+
+			let map_step2=map_step1.add_prop_meshes(
+				//the type conflagulator 9000
+				prop_meshes.into_iter().map(|(mesh_id,loader_model)|
+					(mesh_id,strafesnet_bsp_loader::data::ModelData{
+						mdl:strafesnet_bsp_loader::data::MdlData::new(loader_model.mdl.get()),
+						vtx:strafesnet_bsp_loader::data::VtxData::new(loader_model.vtx.get()),
+						vvd:strafesnet_bsp_loader::data::VvdData::new(loader_model.vvd.get()),
+					})
+				),
+				|name|texture_loader.acquire_render_config_id(name),
+			);
+
+			let (textures,render_configs)=loader.into_render_configs().map_err(LoadError::Io)?.consume();
+
+			let map=map_step2.add_render_configs_and_textures(
+				render_configs.into_iter(),
+				textures.into_iter().map(|(texture_id,texture)|
+					(texture_id,match texture{
+						strafesnet_deferred_loader::texture::Texture::ImageDDS(data)=>data,
+					})
+				),
+			);
+
+			Ok(map)
+		},
+	}
+}

src/graphics_worker.rs

@@ -1,9 +1,8 @@
 pub enum Instruction{
-	Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
+	Render(crate::graphics::FrameState),
 	//UpdateModel(crate::graphics::GraphicsModelUpdate),
 	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
-	GenerateModels(crate::model::IndexedModelInstances),
-	ClearModels,
+	ChangeMap(strafesnet_common::map::CompleteMap),
 }
 
 //Ideally the graphics thread worker description is:
@@ -16,36 +15,32 @@ WorkerDescription{
 //up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
 
 pub fn new<'a>(
-		mut graphics:crate::graphics::GraphicsState,
-		mut config:wgpu::SurfaceConfiguration,
-		surface:wgpu::Surface,
-		device:wgpu::Device,
-		queue:wgpu::Queue,
-	)->crate::compat_worker::INWorker<'a,Instruction>{
+	mut graphics:crate::graphics::GraphicsState,
+	mut config:wgpu::SurfaceConfiguration,
+	surface:wgpu::Surface<'a>,
+	device:wgpu::Device,
+	queue:wgpu::Queue,
+)->crate::compat_worker::INWorker<'a,Instruction>{
 	let mut resize=None;
 	crate::compat_worker::INWorker::new(move |ins:Instruction|{
 		match ins{
-			Instruction::GenerateModels(indexed_model_instances)=>{
-				graphics.generate_models(&device,&queue,indexed_model_instances);
-			},
-			Instruction::ClearModels=>{
+			Instruction::ChangeMap(map)=>{
 				graphics.clear();
+				graphics.generate_models(&device,&queue,&map);
 			},
 			Instruction::Resize(size,user_settings)=>{
 				resize=Some((size,user_settings));
 			}
-			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
-				if let Some((size,user_settings))=&resize{
+			Instruction::Render(frame_state)=>{
+				if let Some((size,user_settings))=resize.take(){
 					println!("Resizing to {:?}",size);
 					let t0=std::time::Instant::now();
 					config.width=size.width.max(1);
 					config.height=size.height.max(1);
 					surface.configure(&device,&config);
-					graphics.resize(&device,&config,user_settings);
+					graphics.resize(&device,&config,&user_settings);
 					println!("Resize took {:?}",t0.elapsed());
 				}
-				//clear every time w/e
-				resize=None;
 				//this has to go deeper somehow
 				let frame=match surface.get_current_texture(){
 					Ok(frame)=>frame,
@@ -61,7 +56,7 @@ pub fn new<'a>(
 					..wgpu::TextureViewDescriptor::default()
 				});
 
-				graphics.render(&view,&device,&queue,physics_output,predicted_time,mouse_pos);
+				graphics.render(&view,&device,&queue,frame_state);
 
 				frame.present();
 			}

src/instruction.rs

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

src/load_bsp.rs

@@ -1,235 +0,0 @@
-const VALVE_SCALE:f32=1.0/16.0;
-fn valve_transform(v:[f32;3])->crate::integer::Planar64Vec3{
-	crate::integer::Planar64Vec3::try_from([v[0]*VALVE_SCALE,v[2]*VALVE_SCALE,-v[1]*VALVE_SCALE]).unwrap()
-}
-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=crate::integer::Planar64Vec3::ZERO;
-
-			let vertices: Vec<_> = bsp
-				.vertices
-				.iter()
-				.map(|vertex|<[f32;3]>::from(vertex.position))
-				.collect();
-
-			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_indexes().map(|vertex_index|{
-						let pos=glam::Vec3A::from_array(vertices[vertex_index as usize]);
-						let pos_idx=spam_pos.len();
-						spam_pos.push(valve_transform(vertices[vertex_index as usize]));
-
-						//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:crate::integer::Planar64Affine3::new(
-							crate::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:crate::integer::Planar64Affine3::new(
-							crate::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)
-		},
-	}
-}

src/load_roblox.rs

@@ -1,523 +0,0 @@
-use crate::primitives;
-use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
-
-fn class_is_a(class: &str, superclass: &str) -> bool {
-	if class==superclass {
-		return true
-	}
-	let class_descriptor=rbx_reflection_database::get().classes.get(class);
-	if let Some(descriptor) = &class_descriptor {
-		if let Some(class_super) = &descriptor.superclass {
-			return class_is_a(&class_super, superclass)
-		}
-	}
-	return false
-}
-fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
-	let mut stack=vec![instance];
-	while let Some(item)=stack.pop(){
-		for &referent in item.children(){
-			if let Some(c)=dom.get_by_ref(referent){
-				if class_is_a(c.class.as_str(),superclass){
-					objects.push(c.referent());//copy ref
-				}
-				stack.push(c);
-			}
-		}
-	}
-}
-fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
-	Planar64Affine3::new(
-		Planar64Mat3::from_cols(
-			Planar64Vec3::try_from([cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x]).unwrap()
-			*Planar64::try_from(size.x/2.0).unwrap(),
-			Planar64Vec3::try_from([cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y]).unwrap()
-			*Planar64::try_from(size.y/2.0).unwrap(),
-			Planar64Vec3::try_from([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z]).unwrap()
-			*Planar64::try_from(size.z/2.0).unwrap(),
-		),
-		Planar64Vec3::try_from([cf.position.x,cf.position.y,cf.position.z]).unwrap()
-	)
-}
-fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_intersecting:bool)->crate::model::CollisionAttributes{
-	let mut general=crate::model::GameMechanicAttributes::default();
-	let mut intersecting=crate::model::IntersectingAttributes::default();
-	let mut contacting=crate::model::ContactingAttributes::default();
-	let mut force_can_collide=can_collide;
-	match name{
-		"Water"=>{
-			force_can_collide=false;
-			//TODO: read stupid CustomPhysicalProperties
-			intersecting.water=Some(crate::model::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
-		},
-		"Accelerator"=>{
-			//although the new game supports collidable accelerators, this is a roblox compatability map loader
-			force_can_collide=false;
-			general.accelerator=Some(crate::model::GameMechanicAccelerator{acceleration:velocity});
-		},
-		// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
-		// 	mode_id:0,
-		// 	stage_id:0,
-		// 	force:false,
-		// 	behaviour:crate::model::StageElementBehaviour::Unordered
-		// })),
-		"SetVelocity"=>general.trajectory=Some(crate::model::GameMechanicSetTrajectory::Velocity(velocity)),
-		"MapFinish"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish})},
-		"MapAnticheat"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat})},
-		"Platform"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
-			mode_id:0,
-			stage_id:0,
-			force:false,
-			behaviour:crate::model::StageElementBehaviour::Platform,
-		})),
-		other=>{
-			if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
-			.captures(other){
-				general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
-					mode_id:0,
-					stage_id:captures[3].parse::<u32>().unwrap(),
-					force:match captures.get(1){
-						Some(m)=>m.as_str()=="Force",
-						None=>false,
-					},
-					behaviour:match &captures[2]{
-						"Spawn"|"SpawnAt"=>crate::model::StageElementBehaviour::SpawnAt,
-						//cancollide false so you don't hit the side
-						//NOT a decoration
-						"Trigger"=>{force_can_collide=false;crate::model::StageElementBehaviour::Trigger},
-						"Teleport"=>{force_can_collide=false;crate::model::StageElementBehaviour::Teleport},
-						"Platform"=>crate::model::StageElementBehaviour::Platform,
-						_=>panic!("regex1[2] messed up bad"),
-					}
-				}));
-			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Jump)(\d+)$")
-			.captures(other){
-				general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
-					mode_id:0,
-					stage_id:0,
-					force:match captures.get(1){
-						Some(m)=>m.as_str()=="Force",
-						None=>false,
-					},
-					behaviour:match &captures[2]{
-						"Jump"=>crate::model::StageElementBehaviour::JumpLimit(captures[3].parse::<u32>().unwrap()),
-						_=>panic!("regex4[1] messed up bad"),
-					}
-				}));
-			}else if let Some(captures)=lazy_regex::regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
-			.captures(other){
-				force_can_collide=false;
-				match &captures[1]{
-					"Finish"=>general.zone=Some(crate::model::GameMechanicZone{mode_id:captures[2].parse::<u32>().unwrap(),behaviour:crate::model::ZoneBehaviour::Finish}),
-					"Anticheat"=>general.zone=Some(crate::model::GameMechanicZone{mode_id:captures[2].parse::<u32>().unwrap(),behaviour:crate::model::ZoneBehaviour::Anitcheat}),
-					_=>panic!("regex2[1] messed up bad"),
-				}
-			}else if let Some(captures)=lazy_regex::regex!(r"^(WormholeIn)(\d+)$")
-			.captures(other){
-				force_can_collide=false;
-				match &captures[1]{
-					"WormholeIn"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::Wormhole(crate::model::GameMechanicWormhole{destination_model_id:captures[2].parse::<u32>().unwrap()})),
-					_=>panic!("regex3[1] messed up bad"),
-				}
-			}
-			// else if let Some(captures)=lazy_regex::regex!(r"^(OrderedCheckpoint)(\d+)$")
-			// .captures(other){
-			// 	match &captures[1]{
-			// 		"OrderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Ordered{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()}),
-			// 		_=>panic!("regex3[1] messed up bad"),
-			// 	}
-			// }
-		}
-	}
-	//need some way to skip this
-	if velocity!=Planar64Vec3::ZERO{
-		general.booster=Some(crate::model::GameMechanicBooster::Velocity(velocity));
-	}
-	match force_can_collide{
-		true=>{
-			match name{
-				"Bounce"=>contacting.contact_behaviour=Some(crate::model::ContactingBehaviour::Elastic(u32::MAX)),
-				"Surf"=>contacting.contact_behaviour=Some(crate::model::ContactingBehaviour::Surf),
-				"Ladder"=>contacting.contact_behaviour=Some(crate::model::ContactingBehaviour::Ladder(crate::model::ContactingLadder{sticky:true})),
-				_=>(),
-			}
-			crate::model::CollisionAttributes::Contact{contacting,general}
-		},
-		false=>if force_intersecting
-		||general.any()
-		||intersecting.any()
-		{
-			crate::model::CollisionAttributes::Intersect{intersecting,general}
-		}else{
-			crate::model::CollisionAttributes::Decoration
-		},
-	}
-}
-
-struct RobloxAssetId(u64);
-struct RobloxAssetIdParseErr;
-impl std::str::FromStr for RobloxAssetId {
-	type Err=RobloxAssetIdParseErr;
-	fn from_str(s: &str) -> Result<Self, Self::Err>{
-		let regman=lazy_regex::regex!(r"(\d+)$");
-		if let Some(captures) = regman.captures(s) {
-			if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
-				if let Ok(id) = captures[0].parse::<u64>() {
-					return Ok(Self(id));
-				}
-			}
-		}
-		Err(RobloxAssetIdParseErr)
-	}
-}
-#[derive(Clone,Copy,PartialEq)]
-struct RobloxTextureTransform{
-	offset_u:f32,
-	offset_v:f32,
-	scale_u:f32,
-	scale_v:f32,
-}
-impl std::cmp::Eq for RobloxTextureTransform{}//????
-impl std::default::Default for RobloxTextureTransform{
-    fn default() -> Self {
-        Self{offset_u:0.0,offset_v:0.0,scale_u:1.0,scale_v:1.0}
-    }
-}
-impl std::hash::Hash for RobloxTextureTransform {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.offset_u.to_ne_bytes().hash(state);
-		self.offset_v.to_ne_bytes().hash(state);
-		self.scale_u.to_ne_bytes().hash(state);
-		self.scale_v.to_ne_bytes().hash(state);
-	}
-}
-#[derive(Clone,PartialEq)]
-struct RobloxFaceTextureDescription{
-	texture:u32,
-	color:glam::Vec4,
-	transform:RobloxTextureTransform,
-}
-impl std::cmp::Eq for RobloxFaceTextureDescription{}//????
-impl std::hash::Hash for RobloxFaceTextureDescription {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.texture.hash(state);
-		self.transform.hash(state);
-        for &el in self.color.as_ref().iter() {
-            el.to_ne_bytes().hash(state);
-        }
-    }
-}
-impl RobloxFaceTextureDescription{
-	fn to_face_description(&self)->primitives::FaceDescription{
-		primitives::FaceDescription{
-			texture:Some(self.texture),
-			transform:glam::Affine2::from_translation(
-				glam::vec2(self.transform.offset_u,self.transform.offset_v)
-			)
-			*glam::Affine2::from_scale(
-				glam::vec2(self.transform.scale_u,self.transform.scale_v)
-			),
-			color:self.color,
-		}
-	}
-}
-type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
-type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
-type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
-#[derive(Clone,Eq,Hash,PartialEq)]
-enum RobloxBasePartDescription{
-	Sphere(RobloxPartDescription),
-	Part(RobloxPartDescription),
-	Cylinder(RobloxPartDescription),
-	Wedge(RobloxWedgeDescription),
-	CornerWedge(RobloxCornerWedgeDescription),
-}
-pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::IndexedModelInstances{
-	//IndexedModelInstances includes textures
-	let mut spawn_point=Planar64Vec3::ZERO;
-
-	let mut indexed_models=Vec::new();
-	let mut model_id_from_description=std::collections::HashMap::<RobloxBasePartDescription,usize>::new();
-
-	let mut texture_id_from_asset_id=std::collections::HashMap::<u64,u32>::new();
-	let mut asset_id_from_texture_id=Vec::new();
-
-	let mut object_refs=Vec::new();
-	let mut temp_objects=Vec::new();
-	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),"BasePart");
-	for object_ref in object_refs {
-		if let Some(object)=dom.get_by_ref(object_ref){
-			if let (
-					Some(rbx_dom_weak::types::Variant::CFrame(cf)),
-					Some(rbx_dom_weak::types::Variant::Vector3(size)),
-					Some(rbx_dom_weak::types::Variant::Vector3(velocity)),
-					Some(rbx_dom_weak::types::Variant::Float32(transparency)),
-					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
-					Some(rbx_dom_weak::types::Variant::Bool(can_collide)),
-				) = (
-					object.properties.get("CFrame"),
-					object.properties.get("Size"),
-					object.properties.get("Velocity"),
-					object.properties.get("Transparency"),
-					object.properties.get("Color"),
-					object.properties.get("CanCollide"),
-				)
-			{
-				let model_transform=planar64_affine3_from_roblox(cf,size);
-
-				if model_transform.matrix3.determinant()==Planar64::ZERO{
-					let mut parent_ref=object.parent();
-					let mut full_path=object.name.clone();
-					while let Some(parent)=dom.get_by_ref(parent_ref){
-						full_path=format!("{}.{}",parent.name,full_path);
-						parent_ref=parent.parent();
-					}
-					println!("Zero determinant CFrame at location {}",full_path);
-					println!("matrix3:{}",model_transform.matrix3);
-					continue;
-				}
-
-				//push TempIndexedAttributes
-				let mut force_intersecting=false;
-				let mut temp_indexing_attributes=Vec::new();
-				if let Some(attr)=match &object.name[..]{
-					"MapStart"=>{
-						spawn_point=model_transform.transform_point3(Planar64Vec3::ZERO)+Planar64Vec3::Y*5/2;
-						Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:0}))
-					},
-					other=>{
-						let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|WormholeOut)(\d+)$");
-						if let Some(captures) = regman.captures(other) {
-							match &captures[1]{
-								"BonusStart"=>Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:captures[2].parse::<u32>().unwrap()})),
-								"Spawn"|"ForceSpawn"=>Some(crate::model::TempIndexedAttributes::Spawn(crate::model::TempAttrSpawn{mode_id:0,stage_id:captures[2].parse::<u32>().unwrap()})),
-								"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
-								_=>None,
-							}
-						}else{
-							None
-						}
-					}
-				}{
-					force_intersecting=true;
-					temp_indexing_attributes.push(attr);
-				}
-
-				//TODO: also detect "CylinderMesh" etc here
-				let shape=match &object.class[..]{
-					"Part"=>{
-						if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
-							match shape.to_u32(){
-								0=>primitives::Primitives::Sphere,
-								1=>primitives::Primitives::Cube,
-								2=>primitives::Primitives::Cylinder,
-								3=>primitives::Primitives::Wedge,
-								4=>primitives::Primitives::CornerWedge,
-								_=>panic!("Funky roblox PartType={};",shape.to_u32()),
-							}
-						}else{
-							panic!("Part has no Shape!");
-						}
-					},
-					"TrussPart"=>primitives::Primitives::Cube,
-					"WedgePart"=>primitives::Primitives::Wedge,
-					"CornerWedgePart"=>primitives::Primitives::CornerWedge,
-					_=>{
-						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
-						primitives::Primitives::Cube
-					}
-				};
-
-				//use the biggest one and cut it down later...
-				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
-				temp_objects.clear();
-				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
-				for &decal_ref in &temp_objects{
-					if let Some(decal)=dom.get_by_ref(decal_ref){
-						if let (
-							Some(rbx_dom_weak::types::Variant::Content(content)),
-							Some(rbx_dom_weak::types::Variant::Enum(normalid)),
-							Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
-							Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
-						) = (
-							decal.properties.get("Texture"),
-							decal.properties.get("Face"),
-							decal.properties.get("Color3"),
-							decal.properties.get("Transparency"),
-						) {
-							if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
-								let texture_id=if let Some(&texture_id)=texture_id_from_asset_id.get(&asset_id.0){
-									texture_id
-								}else{
-									let texture_id=asset_id_from_texture_id.len() as u32;
-									texture_id_from_asset_id.insert(asset_id.0,texture_id);
-									asset_id_from_texture_id.push(asset_id.0);
-									texture_id
-								};
-								let normal_id=normalid.to_u32();
-								if normal_id<6{
-									let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
-										//generate tranform
-										if let (
-												Some(rbx_dom_weak::types::Variant::Float32(ox)),
-												Some(rbx_dom_weak::types::Variant::Float32(oy)),
-												Some(rbx_dom_weak::types::Variant::Float32(sx)),
-												Some(rbx_dom_weak::types::Variant::Float32(sy)),
-											) = (
-												decal.properties.get("OffsetStudsU"),
-												decal.properties.get("OffsetStudsV"),
-												decal.properties.get("StudsPerTileU"),
-												decal.properties.get("StudsPerTileV"),
-											)
-										{
-											let (size_u,size_v)=match normal_id{
-												0=>(size.z,size.y),//right
-												1=>(size.x,size.z),//top
-												2=>(size.x,size.y),//back
-												3=>(size.z,size.y),//left
-												4=>(size.x,size.z),//bottom
-												5=>(size.x,size.y),//front
-												_=>panic!("unreachable"),
-											};
-											(
-												glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
-												RobloxTextureTransform{
-													offset_u:*ox/(*sx),offset_v:*oy/(*sy),
-													scale_u:size_u/(*sx),scale_v:size_v/(*sy),
-												}
-											)
-										}else{
-											(glam::Vec4::ONE,RobloxTextureTransform::default())
-										}
-									}else{
-										(glam::Vec4::ONE,RobloxTextureTransform::default())
-									};
-									part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
-										texture:texture_id,
-										color:roblox_texture_color,
-										transform:roblox_texture_transform,
-									});
-								}else{
-									println!("NormalId={} unsupported for shape={:?}",normal_id,shape);
-								}
-							}
-						}
-					}
-				}
-				//obscure rust syntax "slice pattern"
-				let [
-					f0,//Cube::Right
-					f1,//Cube::Top
-					f2,//Cube::Back
-					f3,//Cube::Left
-					f4,//Cube::Bottom
-					f5,//Cube::Front
-				]=part_texture_description;
-				let basepart_texture_description=match shape{
-					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere([f0,f1,f2,f3,f4,f5]),
-					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
-					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder([f0,f1,f2,f3,f4,f5]),
-					//use front face texture first and use top face texture as a fallback
-					primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
-						f0,//Cube::Right->Wedge::Right
-						if f5.is_some(){f5}else{f1},//Cube::Front|Cube::Top->Wedge::TopFront
-						f2,//Cube::Back->Wedge::Back
-						f3,//Cube::Left->Wedge::Left
-						f4,//Cube::Bottom->Wedge::Bottom
-					]),
-					//TODO: fix Left+Back texture coordinates to match roblox when not overwridden by Top
-					primitives::Primitives::CornerWedge=>RobloxBasePartDescription::CornerWedge([
-						f0,//Cube::Right->CornerWedge::Right
-						if f2.is_some(){f2}else{f1.clone()},//Cube::Back|Cube::Top->CornerWedge::TopBack
-						if f3.is_some(){f3}else{f1},//Cube::Left|Cube::Top->CornerWedge::TopLeft
-						f4,//Cube::Bottom->CornerWedge::Bottom
-						f5,//Cube::Front->CornerWedge::Front
-					]),
-				};
-				//make new model if unit cube has not been created before
-				let model_id=if let Some(&model_id)=model_id_from_description.get(&basepart_texture_description){
-					//push to existing texture model
-					model_id
-				}else{
-					let model_id=indexed_models.len();
-					model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
-					indexed_models.push(match basepart_texture_description{
-						RobloxBasePartDescription::Sphere(part_texture_description)
-						|RobloxBasePartDescription::Cylinder(part_texture_description)
-						|RobloxBasePartDescription::Part(part_texture_description)=>{
-							let mut cube_face_description=primitives::CubeFaceDescription::default();
-							for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
-								cube_face_description.insert(
-								match face_id{
-									0=>primitives::CubeFace::Right,
-									1=>primitives::CubeFace::Top,
-									2=>primitives::CubeFace::Back,
-									3=>primitives::CubeFace::Left,
-									4=>primitives::CubeFace::Bottom,
-									5=>primitives::CubeFace::Front,
-									_=>panic!("unreachable"),
-								},
-								match roblox_face_description{
-									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
-									None=>primitives::FaceDescription::default(),
-								});
-							}
-							primitives::generate_partial_unit_cube(cube_face_description)
-						},
-						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
-							let mut wedge_face_description=primitives::WedgeFaceDescription::default();
-							for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
-								wedge_face_description.insert(
-								match face_id{
-									0=>primitives::WedgeFace::Right,
-									1=>primitives::WedgeFace::TopFront,
-									2=>primitives::WedgeFace::Back,
-									3=>primitives::WedgeFace::Left,
-									4=>primitives::WedgeFace::Bottom,
-									_=>panic!("unreachable"),
-								},
-								match roblox_face_description{
-									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
-									None=>primitives::FaceDescription::default(),
-								});
-							}
-							primitives::generate_partial_unit_wedge(wedge_face_description)
-						},
-						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
-							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::default();
-							for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
-								cornerwedge_face_description.insert(
-								match face_id{
-									0=>primitives::CornerWedgeFace::Right,
-									1=>primitives::CornerWedgeFace::TopBack,
-									2=>primitives::CornerWedgeFace::TopLeft,
-									3=>primitives::CornerWedgeFace::Bottom,
-									4=>primitives::CornerWedgeFace::Front,
-									_=>panic!("unreachable"),
-								},
-								match roblox_face_description{
-									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
-									None=>primitives::FaceDescription::default(),
-								});
-							}
-							primitives::generate_partial_unit_cornerwedge(cornerwedge_face_description)
-						},
-					});
-					model_id
-				};
-				indexed_models[model_id].instances.push(crate::model::ModelInstance {
-					transform:model_transform,
-					color:glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
-					attributes:get_attributes(&object.name,*can_collide,Planar64Vec3::try_from([velocity.x,velocity.y,velocity.z]).unwrap(),force_intersecting),
-					temp_indexing:temp_indexing_attributes,
-				});
-			}
-		}
-	}
-	crate::model::IndexedModelInstances{
-		textures:asset_id_from_texture_id.iter().map(|t|t.to_string()).collect(),
-		models:indexed_models,
-		spawn_point,
-		modes:Vec::new(),
-	}
-}

src/main.rs

@@ -1,18 +1,10 @@
-mod bvh;
-mod aabb;
-mod model;
+mod file;
 mod setup;
 mod window;
 mod worker;
-mod zeroes;
-mod integer;
 mod physics;
 mod graphics;
 mod settings;
-mod primitives;
-mod instruction;
-mod load_bsp;
-mod load_roblox;
 mod face_crawler;
 mod compat_worker;
 mod model_physics;
@@ -20,103 +12,6 @@ mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
 
-fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
-	println!("Loading file: {:?}", &path);
-	//oh boy! let's load the map!
-	if let Ok(file)=std::fs::File::open(path){
-		let mut input = std::io::BufReader::new(file);
-		let mut first_8=[0u8;8];
-		//.rbxm roblox binary = "<roblox!"
-		//.rbxmx roblox xml = "<roblox "
-		//.bsp = "VBSP"
-		//.vmf = 
-		//.snf = "SNMF"
-		//.snf = "SNBF"
-		if let (Ok(()),Ok(()))=(std::io::Read::read_exact(&mut input, &mut first_8),std::io::Seek::rewind(&mut input)){
-			match &first_8[0..4]{
-				b"<rob"=>{
-					match match &first_8[4..8]{
-						b"lox!"=>rbx_binary::from_reader(input).map_err(|e|format!("{:?}",e)),
-						b"lox "=>rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(|e|format!("{:?}",e)),
-						other=>Err(format!("Unknown Roblox file type {:?}",other)),
-					}{
-						Ok(dom)=>Some(load_roblox::generate_indexed_models(dom)),
-						Err(e)=>{
-							println!("Error loading roblox file:{:?}",e);
-							None
-						},
-					}
-				},
-				b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(),
-				//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
-				//b"SNFB"=>Some(sniffer::load_bot(input)),
-				other=>{
-					println!("loser file {:?}",other);
-					None
-				},
-			}
-		}else{
-			println!("Failed to read first 8 bytes and seek back to beginning of file.");
-			None
-		}
-	}else{
-		println!("Could not open file");
-		None
-	}
-}
-
-pub fn default_models()->model::IndexedModelInstances{
-	let mut indexed_models = Vec::new();
-	indexed_models.push(primitives::unit_sphere());
-	indexed_models.push(primitives::unit_cylinder());
-	indexed_models.push(primitives::unit_cube());
-	println!("models.len = {:?}", indexed_models.len());
-	//quad monkeys
-	indexed_models[0].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(10.,5.,10.))).unwrap(),
-		..Default::default()
-	});
-	indexed_models[0].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(20.,5.,10.))).unwrap(),
-		color:glam::vec4(1.0,0.0,0.0,1.0),
-		..Default::default()
-	});
-	indexed_models[0].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(10.,5.,20.))).unwrap(),
-		color:glam::vec4(0.0,1.0,0.0,1.0),
-		..Default::default()
-	});
-	indexed_models[0].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(20.,5.,20.))).unwrap(),
-		color:glam::vec4(0.0,0.0,1.0,1.0),
-		..Default::default()
-	});
-	//decorative monkey
-	indexed_models[0].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(15.,10.,15.))).unwrap(),
-		color:glam::vec4(0.5,0.5,0.5,0.5),
-		attributes:model::CollisionAttributes::Decoration,
-		..Default::default()
-	});
-	//teapot
-	indexed_models[1].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_scale_rotation_translation(glam::vec3(0.5, 1.0, 0.2),glam::quat(-0.22248298016985793,-0.839457167990537,-0.05603504040830783,-0.49261857546227916),glam::vec3(-10.,7.,10.))).unwrap(),
-		..Default::default()
-	});
-	//ground
-	indexed_models[2].instances.push(model::ModelInstance{
-		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(0.,0.,0.))*glam::Affine3A::from_scale(glam::vec3(160.0, 1.0, 160.0))).unwrap(),
-		..Default::default()
-	});
-	model::IndexedModelInstances{
-		textures:Vec::new(),
-		models:indexed_models,
-		spawn_point:integer::Planar64Vec3::Y*50,
-		modes:Vec::new(),
-	}
-}
-
 fn main(){
-	let context=setup::setup(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str());
-	context.start();//creates and runs a window context
+	setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
 }

src/model.rs

@@ -1,321 +0,0 @@
-use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
-pub type TextureCoordinate=glam::Vec2;
-pub type Color4=glam::Vec4;
-#[derive(Clone,Hash,PartialEq,Eq)]
-pub struct IndexedVertex{
-	pub pos:u32,
-	pub tex:u32,
-	pub normal:u32,
-	pub color:u32,
-}
-pub struct IndexedPolygon{
-	pub vertices:Vec<u32>,
-}
-pub struct IndexedGroup{
-	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
-	pub polys:Vec<IndexedPolygon>,
-}
-pub struct IndexedModel{
-	pub unique_pos:Vec<Planar64Vec3>,
-	pub unique_normal:Vec<Planar64Vec3>,
-	pub unique_tex:Vec<TextureCoordinate>,
-	pub unique_color:Vec<Color4>,
-	pub unique_vertices:Vec<IndexedVertex>,
-	pub groups: Vec<IndexedGroup>,
-	pub instances:Vec<ModelInstance>,
-}
-pub struct ModelInstance{
-	//pub id:u64,//this does not actually help with map fixes resimulating bots, they must always be resimulated
-	pub transform:Planar64Affine3,
-	pub color:Color4,//transparency is in here
-	pub attributes:CollisionAttributes,
-	pub temp_indexing:Vec<TempIndexedAttributes>,
-}
-impl std::default::Default for ModelInstance{
-	fn default() -> Self {
-		Self{
-			color:Color4::ONE,
-			transform:Default::default(),
-			attributes:Default::default(),
-			temp_indexing:Default::default(),
-		}
-	}
-}
-pub struct IndexedModelInstances{
-	pub textures:Vec<String>,//RenderPattern
-	pub models:Vec<IndexedModel>,
-	//may make this into an object later.
-	pub modes:Vec<ModeDescription>,
-	pub spawn_point:Planar64Vec3,
-}
-//stage description referencing flattened ids is spooky, but the map loading is meant to be deterministic.
-pub struct ModeDescription{
-	//TODO: put "default" style modifiers in mode
-	//pub style:StyleModifiers,
-	pub start:usize,//start=model_id
-	pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
-	pub spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
-	pub ordered_checkpoint_from_checkpoint_id:std::collections::HashMap::<u32,usize>,
-}
-impl ModeDescription{
-	pub fn get_spawn_model_id(&self,stage_id:u32)->Option<&usize>{
-		self.spawns.get(*self.spawn_from_stage_id.get(&stage_id)?)
-	}
-}
-//I don't want this code to exist!
-#[derive(Clone)]
-pub struct TempAttrStart{
-	pub mode_id:u32,
-}
-#[derive(Clone)]
-pub struct TempAttrSpawn{
-	pub mode_id:u32,
-	pub stage_id:u32,
-}
-#[derive(Clone)]
-pub struct TempAttrWormhole{
-	pub wormhole_id:u32,
-}
-pub enum TempIndexedAttributes{
-	Start(TempAttrStart),
-	Spawn(TempAttrSpawn),
-	Wormhole(TempAttrWormhole),
-}
-
-//you have this effect while in contact
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub struct ContactingLadder{
-	pub sticky:bool
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum ContactingBehaviour{
-	Surf,
-	Cling,//usable as a zipline, or other weird and wonderful things
-	Ladder(ContactingLadder),
-	Elastic(u32),//[1/2^32,1] 0=None (elasticity+1)/2^32
-}
-//you have this effect while intersecting
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub struct IntersectingWater{
-	pub viscosity:Planar64,
-	pub density:Planar64,
-	pub velocity:Planar64Vec3,
-}
-//All models can be given these attributes
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub struct GameMechanicAccelerator{
-	pub acceleration:Planar64Vec3
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum GameMechanicBooster{
-	Affine(Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
-	Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
-	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum TrajectoryChoice{
-	HighArcLongDuration,//underhand lob at target: less horizontal speed and more air time
-	LowArcShortDuration,//overhand throw at target: more horizontal speed and less air time
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum GameMechanicSetTrajectory{
-	//Speed-type SetTrajectory
-	AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
-	Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
-	DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
-	//Velocity-type SetTrajectory
-	TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
-		target_point:Planar64Vec3,
-		time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
-	},
-	TargetPointSpeed{//launch at a fixed speed and land at a target point
-		target_point:Planar64Vec3,
-		speed:Planar64,//if speed is too low this will fail to reach the target.  The closest-passing trajectory will be chosen instead
-		trajectory_choice:TrajectoryChoice,
-	},
-	Velocity(Planar64Vec3),//SetVelocity
-}
-impl GameMechanicSetTrajectory{
-	fn is_velocity(&self)->bool{
-		match self{
-			GameMechanicSetTrajectory::AirTime(_)
-			|GameMechanicSetTrajectory::Height(_)
-			|GameMechanicSetTrajectory::DotVelocity{direction:_,dot:_}=>false,
-			GameMechanicSetTrajectory::TargetPointTime{target_point:_,time:_}
-			|GameMechanicSetTrajectory::TargetPointSpeed{target_point:_,speed:_,trajectory_choice:_}
-			|GameMechanicSetTrajectory::Velocity(_)=>true,
-		}
-	}
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum ZoneBehaviour{
-	//Start is indexed
-	//Checkpoints are indexed
-	Finish,
-	Anitcheat,
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub struct GameMechanicZone{
-	pub mode_id:u32,
-	pub behaviour:ZoneBehaviour,
-}
-// enum TrapCondition{
-// 	FasterThan(Planar64),
-// 	SlowerThan(Planar64),
-// 	InRange(Planar64,Planar64),
-// 	OutsideRange(Planar64,Planar64),
-// }
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum StageElementBehaviour{
-	//Spawn,//The behaviour of stepping on a spawn setting the spawnid
-	SpawnAt,//must be standing on top to get effect. except cancollide false
-	Trigger,
-	Teleport,
-	Platform,
-	//Checkpoint acts like a trigger if you haven't hit all the checkpoints yet.
-	//Note that all stage elements act like this for the next stage.
-	Checkpoint,
-	//OrderedCheckpoint. You must pass through all of these in ascending order.
-	//If you hit them out of order it acts like a trigger.
-	//Do not support backtracking at all for now.
-	Ordered{
-		checkpoint_id:u32,
-	},
-	//UnorderedCheckpoint. You must pass through all of these in any order.
-	Unordered,
-	//If you get reset by a jump limit
-	JumpLimit(u32),
-	//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub struct GameMechanicStageElement{
-	pub mode_id:u32,
-	pub stage_id:u32,//which spawn to send to
-	pub force:bool,//allow setting to lower spawn id i.e. 7->3
-	pub behaviour:StageElementBehaviour
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub struct GameMechanicWormhole{
-	//destination does not need to be another wormhole
-	//this defines a one way portal to a destination model transform
-	//two of these can create a two way wormhole
-	pub destination_model_id:u32,
-	//(position,angles)*=origin.transform.inverse()*destination.transform
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-pub enum TeleportBehaviour{
-	StageElement(GameMechanicStageElement),
-	Wormhole(GameMechanicWormhole),
-}
-//attributes listed in order of handling
-#[derive(Default,Clone,Hash,Eq,PartialEq)]
-pub struct GameMechanicAttributes{
-	pub zone:Option<GameMechanicZone>,
-	pub booster:Option<GameMechanicBooster>,
-	pub trajectory:Option<GameMechanicSetTrajectory>,
-	pub teleport_behaviour:Option<TeleportBehaviour>,
-	pub accelerator:Option<GameMechanicAccelerator>,
-}
-impl GameMechanicAttributes{
-	pub fn any(&self)->bool{
-		self.zone.is_some()
-		||self.booster.is_some()
-		||self.trajectory.is_some()
-		||self.teleport_behaviour.is_some()
-		||self.accelerator.is_some()
-	}
-	pub fn is_wrcp(&self,current_mode_id:u32)->bool{
-		self.trajectory.as_ref().map_or(false,|t|t.is_velocity())
-		&&match &self.teleport_behaviour{
-			Some(TeleportBehaviour::StageElement(
-				GameMechanicStageElement{
-					mode_id,
-					stage_id:_,
-					force:true,
-					behaviour:StageElementBehaviour::Trigger|StageElementBehaviour::Teleport
-				}
-			))=>current_mode_id==*mode_id,
-			_=>false,
-		}
-	}
-}
-#[derive(Default,Clone,Hash,Eq,PartialEq)]
-pub struct ContactingAttributes{
-	//friction?
-	pub contact_behaviour:Option<ContactingBehaviour>,
-}
-impl ContactingAttributes{
-	pub fn any(&self)->bool{
-		self.contact_behaviour.is_some()
-	}
-}
-#[derive(Default,Clone,Hash,Eq,PartialEq)]
-pub struct IntersectingAttributes{
-	pub water:Option<IntersectingWater>,
-}
-impl IntersectingAttributes{
-	pub fn any(&self)->bool{
-		self.water.is_some()
-	}
-}
-//Spawn(u32) NO! spawns are indexed in the map header instead of marked with attibutes
-pub enum CollisionAttributes{
-	Decoration,//visual only
-	Contact{//track whether you are contacting the object
-		contacting:ContactingAttributes,
-		general:GameMechanicAttributes,
-	},
-	Intersect{//track whether you are intersecting the object
-		intersecting:IntersectingAttributes,
-		general:GameMechanicAttributes,
-	},
-}
-impl std::default::Default for CollisionAttributes{
-	fn default() -> Self {
-		Self::Contact{
-			contacting:ContactingAttributes::default(),
-			general:GameMechanicAttributes::default()
-		}
-	}
-}
-
-pub fn generate_indexed_model_list_from_obj(data:obj::ObjData,color:Color4)->Vec<IndexedModel>{
-	let mut unique_vertex_index = std::collections::HashMap::<obj::IndexTuple,u32>::new();
-	return data.objects.iter().map(|object|{
-		unique_vertex_index.clear();
-		let mut unique_vertices = Vec::new();
-		let groups = object.groups.iter().map(|group|{
-			IndexedGroup{
-				texture:None,
-				polys:group.polys.iter().map(|poly|{
-					IndexedPolygon{
-						vertices:poly.0.iter().map(|&tup|{
-							if let Some(&i)=unique_vertex_index.get(&tup){
-								i
-							}else{
-								let i=unique_vertices.len() as u32;
-								unique_vertices.push(IndexedVertex{
-									pos: tup.0 as u32,
-									tex: tup.1.unwrap() as u32,
-									normal: tup.2.unwrap() as u32,
-									color: 0,
-								});
-								unique_vertex_index.insert(tup,i);
-								i
-							}
-						}).collect()
-					}
-				}).collect()
-			}
-		}).collect();
-		IndexedModel{
-			unique_pos: data.position.iter().map(|&v|Planar64Vec3::try_from(v).unwrap()).collect(),
-			unique_tex: data.texture.iter().map(|&v|TextureCoordinate::from_array(v)).collect(),
-			unique_normal: data.normal.iter().map(|&v|Planar64Vec3::try_from(v).unwrap()).collect(),
-			unique_color: vec![color],
-			unique_vertices,
-			groups,
-			instances:Vec::new(),
-		}
-	}).collect()
-}

src/model_graphics.rs

@@ -1,50 +1,39 @@
-use bytemuck::{Pod, Zeroable};
-use crate::model::{IndexedVertex,IndexedPolygon};
-#[derive(Clone, Copy, Pod, Zeroable)]
+use bytemuck::{Pod,Zeroable};
+use strafesnet_common::model::{IndexedVertex,PolygonGroup,RenderConfigId};
+#[derive(Clone,Copy,Pod,Zeroable)]
 #[repr(C)]
-pub struct GraphicsVertex {
-	pub pos: [f32; 3],
-	pub tex: [f32; 2],
-	pub normal: [f32; 3],
-	pub color: [f32; 4],
+pub struct GraphicsVertex{
+	pub pos:[f32;3],
+	pub tex:[f32;2],
+	pub normal:[f32;3],
+	pub color:[f32;4],
 }
-pub struct IndexedGroupFixedTexture{
-	pub polys:Vec<IndexedPolygon>,
-}
-pub struct IndexedGraphicsModelSingleTexture{
-	pub unique_pos:Vec<[f32; 3]>,
-	pub unique_tex:Vec<[f32; 2]>,
-	pub unique_normal:Vec<[f32; 3]>,
-	pub unique_color:Vec<[f32; 4]>,
+#[derive(Clone,Copy,id::Id)]
+pub struct IndexedGraphicsMeshOwnedRenderConfigId(u32);
+pub struct IndexedGraphicsMeshOwnedRenderConfig{
+	pub unique_pos:Vec<[f32;3]>,
+	pub unique_tex:Vec<[f32;2]>,
+	pub unique_normal:Vec<[f32;3]>,
+	pub unique_color:Vec<[f32;4]>,
 	pub unique_vertices:Vec<IndexedVertex>,
-	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
-	pub groups: Vec<IndexedGroupFixedTexture>,
-	pub instances:Vec<GraphicsModelInstance>,
+	pub render_config:RenderConfigId,
+	pub polys:PolygonGroup,
+	pub instances:Vec<GraphicsModelOwned>,
 }
-pub enum Entities{
-	U32(Vec<Vec<u32>>),
-	U16(Vec<Vec<u16>>),
+pub enum Indices{
+	U32(Vec<u32>),
+	U16(Vec<u16>),
 }
-pub struct GraphicsModelSingleTexture{
-	pub instances:Vec<GraphicsModelInstance>,
+pub struct GraphicsMeshOwnedRenderConfig{
 	pub vertices:Vec<GraphicsVertex>,
-	pub entities:Entities,
-	pub texture:Option<u32>,
+	pub indices:Indices,
+	pub render_config:RenderConfigId,
+	pub instances:Vec<GraphicsModelOwned>,
 }
-#[derive(Clone,PartialEq)]
+#[derive(Clone,Copy,PartialEq,id::Id)]
 pub struct GraphicsModelColor4(glam::Vec4);
-impl GraphicsModelColor4{
-	pub const fn get(&self)->glam::Vec4{
-		self.0
-	}
-}
-impl From<glam::Vec4> for GraphicsModelColor4{
-	fn from(value:glam::Vec4)->Self{
-		Self(value)
-	}
-}
 impl std::hash::Hash for GraphicsModelColor4{
-	fn hash<H: std::hash::Hasher>(&self,state:&mut H) {
+	fn hash<H:std::hash::Hasher>(&self,state:&mut H) {
 		for &f in self.0.as_ref(){
 			bytemuck::cast::<f32,u32>(f).hash(state);
 		}
@@ -52,7 +41,7 @@ impl std::hash::Hash for GraphicsModelColor4{
 }
 impl Eq for GraphicsModelColor4{}
 #[derive(Clone)]
-pub struct GraphicsModelInstance{
+pub struct GraphicsModelOwned{
 	pub transform:glam::Mat4,
 	pub normal_transform:glam::Mat3,
 	pub color:GraphicsModelColor4,

src/physics_worker.rs

@@ -1,8 +1,12 @@
-use crate::integer::Time;
-use crate::physics::{MouseState,PhysicsInputInstruction};
-use crate::instruction::{TimedInstruction,InstructionConsumer};
+use strafesnet_common::mouse::MouseState;
+use strafesnet_common::physics::Instruction as PhysicsInputInstruction;
+use strafesnet_common::integer::Time;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::timer::{Scaled,Timer,TimerState};
+use mouse_interpolator::MouseInterpolator;
+
 #[derive(Debug)]
-pub enum InputInstruction {
+pub enum InputInstruction{
 	MoveMouse(glam::IVec2),
 	MoveRight(bool),
 	MoveUp(bool),
@@ -12,122 +16,227 @@ pub enum InputInstruction {
 	MoveForward(bool),
 	Jump(bool),
 	Zoom(bool),
-	Reset,
+	ResetAndRestart,
+	ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
+	PracticeFly,
 }
 pub enum Instruction{
 	Input(InputInstruction),
 	Render,
-	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
-	GenerateModels(crate::model::IndexedModelInstances),
-	ClearModels,
+	Resize(winit::dpi::PhysicalSize<u32>),
+	ChangeMap(strafesnet_common::map::CompleteMap),
+	//SetPaused is not an InputInstruction: the physics doesn't know that it's paused.
+	SetPaused(bool),
 	//Graphics(crate::graphics_worker::Instruction),
 }
+mod mouse_interpolator{
+	use super::*;
+	//TODO: move this or tab
+pub struct MouseInterpolator{
+	//"PlayerController"
+	user_settings:crate::settings::UserSettings,
+	//"MouseInterpolator"
+	timeline:std::collections::VecDeque<TimedInstruction<PhysicsInputInstruction>>,
+	last_mouse_time:Time,//this value is pre-transformed to simulation time
+	mouse_blocking:bool,
+	//"Simulation"
+	timer:Timer<Scaled>,
+	physics:crate::physics::PhysicsContext,
 
-	pub fn new(mut physics:crate::physics::PhysicsState,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
-		let mut mouse_blocking=true;
-		let mut last_mouse_time=physics.next_mouse.time;
-		let mut timeline=std::collections::VecDeque::new();
-		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
-			if if let Some(phys_input)=match &ins.instruction{
-				Instruction::Input(input_instruction)=>match input_instruction{
-					&InputInstruction::MoveMouse(m)=>{
-						if mouse_blocking{
-							//tell the game state which is living in the past about its future
-							timeline.push_front(TimedInstruction{
-								time:last_mouse_time,
-								instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:m}),
-							});
-						}else{
-							//mouse has just started moving again after being still for longer than 10ms.
-							//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
-							timeline.push_front(TimedInstruction{
-								time:last_mouse_time,
-								instruction:PhysicsInputInstruction::ReplaceMouse(
-									MouseState{time:last_mouse_time,pos:physics.next_mouse.pos},
-									MouseState{time:ins.time,pos:m}
-								),
-							});
-							//delay physics execution until we have an interpolation target
-							mouse_blocking=true;
-						}
-						last_mouse_time=ins.time;
-						None
-					},
-					&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
-					&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
-					&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
-					&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
-					&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
-					&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
-					&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
-					&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
-					InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
-				},
-				Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
-				Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
-				Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
-				Instruction::Render=>Some(PhysicsInputInstruction::Idle),
-			}{
-				//non-mouse event
-				timeline.push_back(TimedInstruction{
-					time:ins.time,
-					instruction:phys_input,
-				});
-				
-				if mouse_blocking{
-					//assume the mouse has stopped moving after 10ms.
-					//shitty mice are 125Hz which is 8ms so this should cover that.
-					//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
-					//so mouse events are probably not handled separately from drawing and fire right before it :(
-					if Time::from_millis(10)<ins.time-physics.next_mouse.time{
-						//push an event to extrapolate no movement from
-						timeline.push_front(TimedInstruction{
-							time:last_mouse_time,
-							instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}),
-						});
-						last_mouse_time=ins.time;
-						//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
-						mouse_blocking=false;
-						true
-					}else{
-						false
-					}
-				}else{
-					//keep this up to date so that it can be used as a known-timestamp
-					//that the mouse was not moving when the mouse starts moving again
-					last_mouse_time=ins.time;
-					true
-				}
-			}else{
-				//mouse event
-				true
-			}{
-				//empty queue
-				while let Some(instruction)=timeline.pop_front(){
-					physics.run(instruction.time);
-					physics.process_instruction(TimedInstruction{
-						time:instruction.time,
-						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
-					});
-				}
-			}
-			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();
-				},
-				_=>(),
-			}
-		})
+}
+impl MouseInterpolator{
+	pub fn new(
+		physics:crate::physics::PhysicsContext,
+		user_settings:crate::settings::UserSettings,
+	)->MouseInterpolator{
+		MouseInterpolator{
+			mouse_blocking:true,
+			last_mouse_time:physics.get_next_mouse().time,
+			timeline:std::collections::VecDeque::new(),
+			timer:Timer::from_state(Scaled::identity(),false),
+			physics,
+			user_settings,
+		}
 	}
+	fn push_mouse_instruction(&mut self,ins:&TimedInstruction<Instruction>,m:glam::IVec2){
+		if self.mouse_blocking{
+			//tell the game state which is living in the past about its future
+			self.timeline.push_front(TimedInstruction{
+				time:self.last_mouse_time,
+				instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.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
+			self.timeline.push_front(TimedInstruction{
+				time:self.last_mouse_time,
+				instruction:PhysicsInputInstruction::ReplaceMouse(
+					MouseState{time:self.last_mouse_time,pos:self.physics.get_next_mouse().pos},
+					MouseState{time:self.timer.time(ins.time),pos:m}
+				),
+			});
+			//delay physics execution until we have an interpolation target
+			self.mouse_blocking=true;
+		}
+		self.last_mouse_time=self.timer.time(ins.time);
+	}
+	fn push(&mut self,time:Time,phys_input:PhysicsInputInstruction){
+		//This is always a non-mouse event
+		self.timeline.push_back(TimedInstruction{
+			time:self.timer.time(time),
+			instruction:phys_input,
+		});
+	}
+	/// returns should_empty_queue
+	/// may or may not mutate internal state XD!
+	fn map_instruction(&mut self,ins:&TimedInstruction<Instruction>)->bool{
+		let mut update_mouse_blocking=true;
+		match &ins.instruction{
+			Instruction::Input(input_instruction)=>match input_instruction{
+				&InputInstruction::MoveMouse(m)=>{
+					if !self.timer.is_paused(){
+						self.push_mouse_instruction(ins,m);
+					}
+					update_mouse_blocking=false;
+				},
+				&InputInstruction::MoveForward(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveForward(s)),
+				&InputInstruction::MoveLeft(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveLeft(s)),
+				&InputInstruction::MoveBack(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveBack(s)),
+				&InputInstruction::MoveRight(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveRight(s)),
+				&InputInstruction::MoveUp(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveUp(s)),
+				&InputInstruction::MoveDown(s)=>self.push(ins.time,PhysicsInputInstruction::SetMoveDown(s)),
+				&InputInstruction::Jump(s)=>self.push(ins.time,PhysicsInputInstruction::SetJump(s)),
+				&InputInstruction::Zoom(s)=>self.push(ins.time,PhysicsInputInstruction::SetZoom(s)),
+				&InputInstruction::ResetAndSpawn(mode_id,stage_id)=>{
+					self.push(ins.time,PhysicsInputInstruction::Reset);
+					self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
+					self.push(ins.time,PhysicsInputInstruction::Spawn(mode_id,stage_id));
+				},
+				InputInstruction::ResetAndRestart=>{
+					self.push(ins.time,PhysicsInputInstruction::Reset);
+					self.push(ins.time,PhysicsInputInstruction::SetSensitivity(self.user_settings.calculate_sensitivity()));
+					self.push(ins.time,PhysicsInputInstruction::Restart);
+				},
+				InputInstruction::PracticeFly=>self.push(ins.time,PhysicsInputInstruction::PracticeFly),
+			},
+			//do these really need to idle the physics?
+			//sending None dumps the instruction queue
+			Instruction::ChangeMap(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
+			Instruction::Resize(_)=>self.push(ins.time,PhysicsInputInstruction::Idle),
+			Instruction::Render=>self.push(ins.time,PhysicsInputInstruction::Idle),
+			&Instruction::SetPaused(paused)=>{
+				if let Err(e)=self.timer.set_paused(ins.time,paused){
+					println!("Cannot pause: {e}");
+				}
+				self.push(ins.time,PhysicsInputInstruction::Idle);
+			},
+		}
+		if update_mouse_blocking{
+			//this returns the bool for us
+			self.update_mouse_blocking(ins.time)
+		}else{
+			//do flush that queue
+			true
+		}
+	}
+	/// must check if self.mouse_blocking==true before calling!
+	fn unblock_mouse(&mut self,time:Time){
+		//push an event to extrapolate no movement from
+		self.timeline.push_front(TimedInstruction{
+			time:self.last_mouse_time,
+			instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(time),pos:self.physics.get_next_mouse().pos}),
+		});
+		self.last_mouse_time=self.timer.time(time);
+		//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
+		self.mouse_blocking=false;
+	}
+	fn update_mouse_blocking(&mut self,time:Time)->bool{
+		if self.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)<self.timer.time(time)-self.physics.get_next_mouse().time{
+				self.unblock_mouse(time);
+				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
+			self.last_mouse_time=self.timer.time(time);
+			true
+		}
+	}
+	fn empty_queue(&mut self){
+		while let Some(instruction)=self.timeline.pop_front(){
+			self.physics.run_input_instruction(instruction);
+		}
+	}
+	pub fn handle_instruction(&mut self,ins:&TimedInstruction<Instruction>){
+		let should_empty_queue=self.map_instruction(ins);
+		if should_empty_queue{
+			self.empty_queue();
+		}
+	}
+	pub fn get_frame_state(&self,time:Time)->crate::graphics::FrameState{
+		crate::graphics::FrameState{
+			body:self.physics.camera_body(),
+			camera:self.physics.camera(),
+			time:self.timer.time(time),
+		}
+	}
+	pub fn change_map(&mut self,time:Time,map:&strafesnet_common::map::CompleteMap){
+		//dump any pending interpolation state
+		if self.mouse_blocking{
+			self.unblock_mouse(time);
+		}
+		self.empty_queue();
+
+		//doing it like this to avoid doing PhysicsInstruction::ChangeMap(Rc<CompleteMap>)
+		self.physics.generate_models(&map);
+
+		//use the standard input interface so the instructions are written out to bots
+		self.handle_instruction(&TimedInstruction{
+			time:self.timer.time(time),
+			instruction:Instruction::Input(InputInstruction::ResetAndSpawn(
+				strafesnet_common::gameplay_modes::ModeId::MAIN,
+				strafesnet_common::gameplay_modes::StageId::FIRST,
+			)),
+		});
+	}
+	pub const fn user_settings(&self)->&crate::settings::UserSettings{
+		&self.user_settings
+	}
+}
+}
+
+pub fn new<'a>(
+	mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
+	user_settings:crate::settings::UserSettings,
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction>>{
+	let physics=crate::physics::PhysicsContext::default();
+	let mut interpolator=MouseInterpolator::new(
+		physics,
+		user_settings
+	);
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+		interpolator.handle_instruction(&ins);
+		match ins.instruction{
+			Instruction::Render=>{
+				let frame_state=interpolator.get_frame_state(ins.time);
+				graphics_worker.send(crate::graphics_worker::Instruction::Render(frame_state)).unwrap();
+			},
+			Instruction::Resize(size)=>{
+				graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,interpolator.user_settings().clone())).unwrap();
+			},
+			Instruction::ChangeMap(map)=>{
+				interpolator.change_map(ins.time,&map);
+				graphics_worker.send(crate::graphics_worker::Instruction::ChangeMap(map)).unwrap();
+			},
+			Instruction::Input(_)=>(),
+			Instruction::SetPaused(_)=>(),
+		}
+	})
+}

src/primitives.rs

@@ -1,493 +0,0 @@
-use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
-use crate::integer::Planar64Vec3;
-
-#[derive(Debug)]
-pub enum Primitives{
-	Sphere,
-	Cube,
-	Cylinder,
-	Wedge,
-	CornerWedge,
-}
-#[derive(Hash,PartialEq,Eq)]
-pub enum CubeFace{
-	Right,
-	Top,
-	Back,
-	Left,
-	Bottom,
-	Front,
-}
-const CUBE_DEFAULT_TEXTURE_COORDS:[TextureCoordinate;4]=[
-	TextureCoordinate::new(0.0,0.0),
-	TextureCoordinate::new(1.0,0.0),
-	TextureCoordinate::new(1.0,1.0),
-	TextureCoordinate::new(0.0,1.0),
-];
-const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
-	Planar64Vec3::int(-1,-1, 1),//0 left bottom back
-	Planar64Vec3::int( 1,-1, 1),//1 right bottom back
-	Planar64Vec3::int( 1, 1, 1),//2 right top back
-	Planar64Vec3::int(-1, 1, 1),//3 left top back
-	Planar64Vec3::int(-1, 1,-1),//4 left top front
-	Planar64Vec3::int( 1, 1,-1),//5 right top front
-	Planar64Vec3::int( 1,-1,-1),//6 right bottom front
-	Planar64Vec3::int(-1,-1,-1),//7 left bottom front
-];
-const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
-	Planar64Vec3::int( 1, 0, 0),//CubeFace::Right
-	Planar64Vec3::int( 0, 1, 0),//CubeFace::Top
-	Planar64Vec3::int( 0, 0, 1),//CubeFace::Back
-	Planar64Vec3::int(-1, 0, 0),//CubeFace::Left
-	Planar64Vec3::int( 0,-1, 0),//CubeFace::Bottom
-	Planar64Vec3::int( 0, 0,-1),//CubeFace::Front
-];
-const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
-	// right (1, 0, 0)
-	[
-		[6,2,0],//[vertex,tex,norm]
-		[5,1,0],
-		[2,0,0],
-		[1,3,0],
-	],
-	// top (0, 1, 0)
-	[
-		[5,3,1],
-		[4,2,1],
-		[3,1,1],
-		[2,0,1],
-	],
-	// back (0, 0, 1)
-	[
-		[0,3,2],
-		[1,2,2],
-		[2,1,2],
-		[3,0,2],
-	],
-	// left (-1, 0, 0)
-	[
-		[0,2,3],
-		[3,1,3],
-		[4,0,3],
-		[7,3,3],
-	],
-	// bottom (0,-1, 0)
-	[
-		[1,1,4],
-		[0,0,4],
-		[7,3,4],
-		[6,2,4],
-	],
-	// front (0, 0,-1)
-	[
-		[4,1,5],
-		[5,0,5],
-		[6,3,5],
-		[7,2,5],
-	],
-];
-
-#[derive(Hash,PartialEq,Eq)]
-pub enum WedgeFace{
-	Right,
-	TopFront,
-	Back,
-	Left,
-	Bottom,
-}
-const WEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
-	Planar64Vec3::int( 1, 0, 0),//Wedge::Right
-	Planar64Vec3::int( 0, 1,-1),//Wedge::TopFront
-	Planar64Vec3::int( 0, 0, 1),//Wedge::Back
-	Planar64Vec3::int(-1, 0, 0),//Wedge::Left
-	Planar64Vec3::int( 0,-1, 0),//Wedge::Bottom
-];
-/*
-local cornerWedgeVerticies = {
-	Vector3.new(-1/2,-1/2,-1/2),7
-	Vector3.new(-1/2,-1/2, 1/2),0
-	Vector3.new( 1/2,-1/2,-1/2),6
-	Vector3.new( 1/2,-1/2, 1/2),1
-	Vector3.new( 1/2, 1/2,-1/2),5
-}
-*/
-#[derive(Hash,PartialEq,Eq)]
-pub enum CornerWedgeFace{
-	Right,
-	TopBack,
-	TopLeft,
-	Bottom,
-	Front,
-}
-const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
-	Planar64Vec3::int( 1, 0, 0),//CornerWedge::Right
-	Planar64Vec3::int( 0, 1, 1),//CornerWedge::BackTop
-	Planar64Vec3::int(-1, 1, 0),//CornerWedge::LeftTop
-	Planar64Vec3::int( 0,-1, 0),//CornerWedge::Bottom
-	Planar64Vec3::int( 0, 0,-1),//CornerWedge::Front
-];
-pub fn unit_sphere()->crate::model::IndexedModel{
-	unit_cube()
-}
-#[derive(Default)]
-pub struct CubeFaceDescription([Option<FaceDescription>;6]);
-impl CubeFaceDescription{
-	pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
-		self.0[index as usize]=Some(value);
-	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,6>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
-	}
-}
-pub fn unit_cube()->crate::model::IndexedModel{
-	let mut t=CubeFaceDescription::default();
-	t.insert(CubeFace::Right,FaceDescription::default());
-	t.insert(CubeFace::Top,FaceDescription::default());
-	t.insert(CubeFace::Back,FaceDescription::default());
-	t.insert(CubeFace::Left,FaceDescription::default());
-	t.insert(CubeFace::Bottom,FaceDescription::default());
-	t.insert(CubeFace::Front,FaceDescription::default());
-	generate_partial_unit_cube(t)
-}
-pub fn unit_cylinder()->crate::model::IndexedModel{
-	unit_cube()
-}
-#[derive(Default)]
-pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
-impl WedgeFaceDescription{
-	pub fn insert(&mut self,index:WedgeFace,value:FaceDescription){
-		self.0[index as usize]=Some(value);
-	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
-	}
-}
-pub fn unit_wedge()->crate::model::IndexedModel{
-	let mut t=WedgeFaceDescription::default();
-	t.insert(WedgeFace::Right,FaceDescription::default());
-	t.insert(WedgeFace::TopFront,FaceDescription::default());
-	t.insert(WedgeFace::Back,FaceDescription::default());
-	t.insert(WedgeFace::Left,FaceDescription::default());
-	t.insert(WedgeFace::Bottom,FaceDescription::default());
-	generate_partial_unit_wedge(t)
-}
-#[derive(Default)]
-pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
-impl CornerWedgeFaceDescription{
-	pub fn insert(&mut self,index:CornerWedgeFace,value:FaceDescription){
-		self.0[index as usize]=Some(value);
-	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
-	}
-}
-pub fn unit_cornerwedge()->crate::model::IndexedModel{
-	let mut t=CornerWedgeFaceDescription::default();
-	t.insert(CornerWedgeFace::Right,FaceDescription::default());
-	t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
-	t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
-	t.insert(CornerWedgeFace::Bottom,FaceDescription::default());
-	t.insert(CornerWedgeFace::Front,FaceDescription::default());
-	generate_partial_unit_cornerwedge(t)
-}
-
-#[derive(Clone)]
-pub struct FaceDescription{
-	pub texture:Option<u32>,
-	pub transform:glam::Affine2,
-	pub color:Color4,
-}
-impl std::default::Default for FaceDescription{
-	fn default()->Self {
-		Self{
-			texture:None,
-			transform:glam::Affine2::IDENTITY,
-			color:Color4::new(1.0,1.0,1.0,0.0),//zero alpha to hide the default texture
-		}
-	}
-}
-//TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
-//implementation: put all roblox primitives into one model.groups <- this won't work but I forget why
-pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate::model::IndexedModel{
-	let mut generated_pos=Vec::new();
-	let mut generated_tex=Vec::new();
-	let mut generated_normal=Vec::new();
-	let mut generated_color=Vec::new();
-	let mut generated_vertices=Vec::new();
-	let mut groups=Vec::new();
-	let mut transforms=Vec::new();
-	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.pairs(){
-		//assume that scanning short lists is faster than hashing.
-		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
-			transform_index
-		}else{
-			//create new transform_index
-			let transform_index=transforms.len();
-			transforms.push(face_description.transform);
-			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
-				generated_tex.push(face_description.transform.transform_point2(tex));
-			}
-			transform_index
-		} as u32;
-		let color_index=if let Some(color_index)=generated_color.iter().position(|&color|color==face_description.color){
-			color_index
-		}else{
-			//create new color_index
-			let color_index=generated_color.len();
-			generated_color.push(face_description.color);
-			color_index
-		} as u32;
-		//always push normal
-		let normal_index=generated_normal.len() as u32;
-		generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
-		//push vertices as they are needed
-		groups.push(IndexedGroup{
-			texture:face_description.texture,
-			polys:vec![IndexedPolygon{
-				vertices:CUBE_DEFAULT_POLYS[face_id].map(|tup|{
-					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
-					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
-						pos_index
-					}else{
-						//create new pos_index
-						let pos_index=generated_pos.len();
-						generated_pos.push(pos);
-						pos_index
-					} as u32;
-					//always push vertex
-					let vertex=IndexedVertex{
-						pos:pos_index,
-						tex:tup[1]+4*transform_index,
-						normal:normal_index,
-						color:color_index,
-					};
-					let vert_index=generated_vertices.len();
-					generated_vertices.push(vertex);
-					vert_index as u32
-				}).to_vec(),
-			}],
-		});
-	}
-	IndexedModel{
-		unique_pos:generated_pos,
-		unique_tex:generated_tex,
-		unique_normal:generated_normal,
-		unique_color:generated_color,
-		unique_vertices:generated_vertices,
-		groups,
-		instances:Vec::new(),
-	}
-}
-//don't think too hard about the copy paste because this is all going into the map tool eventually...
-pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crate::model::IndexedModel{
-	let wedge_default_polys=vec![
-		// right (1, 0, 0)
-		vec![
-			[6,2,0],//[vertex,tex,norm]
-			[2,0,0],
-			[1,3,0],
-		],
-		// FrontTop (0, 1, -1)
-		vec![
-			[3,1,1],
-			[2,0,1],
-			[6,3,1],
-			[7,2,1],
-		],
-		// back (0, 0, 1)
-		vec![
-			[0,3,2],
-			[1,2,2],
-			[2,1,2],
-			[3,0,2],
-		],
-		// left (-1, 0, 0)
-		vec![
-			[0,2,3],
-			[3,1,3],
-			[7,3,3],
-		],
-		// bottom (0,-1, 0)
-		vec![
-			[1,1,4],
-			[0,0,4],
-			[7,3,4],
-			[6,2,4],
-		],
-	];
-	let mut generated_pos=Vec::new();
-	let mut generated_tex=Vec::new();
-	let mut generated_normal=Vec::new();
-	let mut generated_color=Vec::new();
-	let mut generated_vertices=Vec::new();
-	let mut groups=Vec::new();
-	let mut transforms=Vec::new();
-	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.pairs(){
-		//assume that scanning short lists is faster than hashing.
-		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
-			transform_index
-		}else{
-			//create new transform_index
-			let transform_index=transforms.len();
-			transforms.push(face_description.transform);
-			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
-				generated_tex.push(face_description.transform.transform_point2(tex));
-			}
-			transform_index
-		} as u32;
-		let color_index=if let Some(color_index)=generated_color.iter().position(|&color|color==face_description.color){
-			color_index
-		}else{
-			//create new color_index
-			let color_index=generated_color.len();
-			generated_color.push(face_description.color);
-			color_index
-		} as u32;
-		//always push normal
-		let normal_index=generated_normal.len() as u32;
-		generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
-		//push vertices as they are needed
-		groups.push(IndexedGroup{
-			texture:face_description.texture,
-			polys:vec![IndexedPolygon{
-				vertices:wedge_default_polys[face_id].iter().map(|tup|{
-					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
-					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
-						pos_index
-					}else{
-						//create new pos_index
-						let pos_index=generated_pos.len();
-						generated_pos.push(pos);
-						pos_index
-					} as u32;
-					//always push vertex
-					let vertex=IndexedVertex{
-						pos:pos_index,
-						tex:tup[1]+4*transform_index,
-						normal:normal_index,
-						color:color_index,
-					};
-					let vert_index=generated_vertices.len();
-					generated_vertices.push(vertex);
-					vert_index as u32
-				}).collect(),
-			}],
-		});
-	}
-	IndexedModel{
-		unique_pos:generated_pos,
-		unique_tex:generated_tex,
-		unique_normal:generated_normal,
-		unique_color:generated_color,
-		unique_vertices:generated_vertices,
-		groups,
-		instances:Vec::new(),
-	}
-}
-
-pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescription)->crate::model::IndexedModel{
-	let cornerwedge_default_polys=vec![
-		// right (1, 0, 0)
-		vec![
-			[6,2,0],//[vertex,tex,norm]
-			[5,1,0],
-			[1,3,0],
-		],
-		// BackTop (0, 1, 1)
-		vec![
-			[5,3,1],
-			[0,1,1],
-			[1,0,1],
-		],
-		// LeftTop (-1, 1, 0)
-		vec![
-			[5,3,2],
-			[7,2,2],
-			[0,1,2],
-		],
-		// bottom (0,-1, 0)
-		vec![
-			[1,1,3],
-			[0,0,3],
-			[7,3,3],
-			[6,2,3],
-		],
-		// front (0, 0,-1)
-		vec![
-			[5,0,4],
-			[6,3,4],
-			[7,2,4],
-		],
-	];
-	let mut generated_pos=Vec::new();
-	let mut generated_tex=Vec::new();
-	let mut generated_normal=Vec::new();
-	let mut generated_color=Vec::new();
-	let mut generated_vertices=Vec::new();
-	let mut groups=Vec::new();
-	let mut transforms=Vec::new();
-	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.pairs(){
-		//assume that scanning short lists is faster than hashing.
-		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
-			transform_index
-		}else{
-			//create new transform_index
-			let transform_index=transforms.len();
-			transforms.push(face_description.transform);
-			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
-				generated_tex.push(face_description.transform.transform_point2(tex));
-			}
-			transform_index
-		} as u32;
-		let color_index=if let Some(color_index)=generated_color.iter().position(|&color|color==face_description.color){
-			color_index
-		}else{
-			//create new color_index
-			let color_index=generated_color.len();
-			generated_color.push(face_description.color);
-			color_index
-		} as u32;
-		//always push normal
-		let normal_index=generated_normal.len() as u32;
-		generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);
-		//push vertices as they are needed
-		groups.push(IndexedGroup{
-			texture:face_description.texture,
-			polys:vec![IndexedPolygon{
-				vertices:cornerwedge_default_polys[face_id].iter().map(|tup|{
-					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
-					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
-						pos_index
-					}else{
-						//create new pos_index
-						let pos_index=generated_pos.len();
-						generated_pos.push(pos);
-						pos_index
-					} as u32;
-					//always push vertex
-					let vertex=IndexedVertex{
-						pos:pos_index,
-						tex:tup[1]+4*transform_index,
-						normal:normal_index,
-						color:color_index,
-					};
-					let vert_index=generated_vertices.len();
-					generated_vertices.push(vertex);
-					vert_index as u32
-				}).collect(),
-			}],
-		});
-	}
-	IndexedModel{
-		unique_pos:generated_pos,
-		unique_tex:generated_tex,
-		unique_normal:generated_normal,
-		unique_color:generated_color,
-		unique_vertices:generated_vertices,
-		groups,
-		instances:Vec::new(),
-	}
-}

src/settings.rs

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

src/setup.rs

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

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/window.rs

@@ -1,5 +1,6 @@
-use crate::instruction::TimedInstruction;
 use crate::physics_worker::InputInstruction;
+use strafesnet_common::integer;
+use strafesnet_common::instruction::TimedInstruction;
 
 pub enum WindowInstruction{
 	Resize(winit::dpi::PhysicalSize<u32>),
@@ -12,10 +13,9 @@ pub enum WindowInstruction{
 //holds thread handles to dispatch to
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
-	mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
+	mouse:strafesnet_common::mouse::MouseState,//std::sync::Arc<std::sync::Mutex<>>
 	screen_size:glam::UVec2,
-	user_settings:crate::settings::UserSettings,
-	window:winit::window::Window,
+	window:&'a winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
 }
 
@@ -23,17 +23,20 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0)
 	}
-	fn window_event(&mut self,time:crate::integer::Time,event: winit::event::WindowEvent) {
+	fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) {
 		match event {
 			winit::event::WindowEvent::DroppedFile(path)=>{
-				//blocking because it's simpler...
-				if let Some(indexed_model_instances)=crate::load_file(path){
-					self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ClearModels}).unwrap();
-					self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::GenerateModels(indexed_model_instances)}).unwrap();
+				match crate::file::load(path.as_path()){
+					Ok(map)=>self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ChangeMap(map)}).unwrap(),
+					Err(e)=>println!("Failed to load map: {e}"),
 				}
 			},
-			winit::event::WindowEvent::Focused(_state)=>{
+			winit::event::WindowEvent::Focused(state)=>{
 				//pause unpause
+				self.physics_thread.send(TimedInstruction{
+					time,
+					instruction:crate::physics_worker::Instruction::SetPaused(!state),
+				}).unwrap();
 				//recalculate pressed keys on focus
 			},
 			winit::event::WindowEvent::KeyboardInput{
@@ -104,7 +107,12 @@ impl WindowContext<'_>{
 								"e"=>Some(InputInstruction::MoveUp(s)),
 								"q"=>Some(InputInstruction::MoveDown(s)),
 								"z"=>Some(InputInstruction::Zoom(s)),
-								"r"=>if s{Some(InputInstruction::Reset)}else{None},
+								"r"=>if s{
+									//mouse needs to be reset since the position is absolute
+									self.mouse=strafesnet_common::mouse::MouseState::default();
+									Some(InputInstruction::ResetAndRestart)
+								}else{None},
+								"f"=>if s{Some(InputInstruction::PracticeFly)}else{None},
 								_=>None,
 							},
 							_=>None,
@@ -121,7 +129,7 @@ impl WindowContext<'_>{
 		}
 	}
 
-	fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
+	fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
 		match event {
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
@@ -157,59 +165,32 @@ impl WindowContext<'_>{
 		}
 	}
 }
-
-pub struct WindowContextSetup{
-	user_settings:crate::settings::UserSettings,
-	window:winit::window::Window,
-	physics:crate::physics::PhysicsState,
-	graphics:crate::graphics::GraphicsState,
-}
-
-impl WindowContextSetup{
-	pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
-		//wee
+pub fn worker<'a>(
+	window:&'a winit::window::Window,
+	setup_context:crate::setup::SetupContext<'a>,
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
+	// WindowContextSetup::new
 		let user_settings=crate::settings::read_user_settings();
 
-		let args:Vec<String>=std::env::args().collect();
-		let indexed_model_instances=if args.len()==2{
-			crate::load_file(std::path::PathBuf::from(&args[1]))
-		}else{
-			None
-		}.unwrap_or(crate::default_models());
-
-		let mut physics=crate::physics::PhysicsState::default();
-		physics.load_user_settings(&user_settings);
-		physics.generate_models(&indexed_model_instances);
-		physics.spawn(indexed_model_instances.spawn_point);
-
-		let mut graphics=crate::graphics::GraphicsState::new(&context.device,&context.queue,&context.config);
+		let mut graphics=crate::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
 		graphics.load_user_settings(&user_settings);
-		graphics.generate_models(&context.device,&context.queue,indexed_model_instances);
 
-		Self{
-			user_settings,
-			window,
-			graphics,
-			physics,
-		}
-	}
-
-	fn into_context<'a>(self,setup_context:crate::setup::SetupContext)->WindowContext<'a>{
+	//WindowContextSetup::into_context
 		let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
-		let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
-		WindowContext{
+		let graphics_thread=crate::graphics_worker::new(graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
+		let mut window_context=WindowContext{
 			manual_mouse_lock:false,
-			mouse:crate::physics::MouseState::default(),
+			mouse:strafesnet_common::mouse::MouseState::default(),
 			//make sure to update this!!!!!
 			screen_size,
-			user_settings:self.user_settings,
-			window:self.window,
-			physics_thread:crate::physics_worker::new(self.physics,graphics_thread),
-		}
-	}
+			window,
+			physics_thread:crate::physics_worker::new(
+				graphics_thread,
+				user_settings,
+			),
+		};
 
-	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);
+	//WindowContextSetup::into_worker
 		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
 			match ins.instruction{
 				WindowInstruction::RequestRedraw=>{
@@ -225,7 +206,7 @@ impl WindowContextSetup{
 					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::Resize(size)
 						}
 					).unwrap();
 				}
@@ -239,5 +220,4 @@ impl WindowContextSetup{
 				}
 			}
 		})
-	}
 }

src/worker.rs

@@ -173,38 +173,44 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 	}
 }
 
-#[test]//How to run this test with printing: cargo test --release -- --nocapture
-fn test_worker() {
-	// Create the worker thread
-	let test_body=crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO);
-	let worker=QRWorker::new(crate::physics::Body::default(),
-		|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
-	);
+#[cfg(test)]
+mod test{
+	use super::{thread,QRWorker};
+	use crate::physics;
+	use strafesnet_common::{integer,instruction};
+	#[test]//How to run this test with printing: cargo test --release -- --nocapture
+	fn test_worker() {
+		// Create the worker thread
+		let test_body=physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO);
+		let worker=QRWorker::new(physics::Body::ZERO,
+			|_|physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO)
+		);
 
-	// Send tasks to the worker
-	for _ in 0..5 {
-		let task = crate::instruction::TimedInstruction{
-			time:crate::integer::Time::ZERO,
-			instruction:crate::physics::PhysicsInstruction::StrafeTick,
+		// Send tasks to the worker
+		for _ in 0..5 {
+			let task = instruction::TimedInstruction{
+				time:integer::Time::ZERO,
+				instruction:strafesnet_common::physics::Instruction::Idle,
+			};
+			worker.send(task).unwrap();
+		}
+
+		// Optional: Signal the worker to stop (in a real-world scenario)
+		// sender.send("STOP".to_string()).unwrap();
+
+		// Sleep to allow the worker thread to finish processing
+		thread::sleep(std::time::Duration::from_millis(10));
+
+		// Send a new task
+		let task = instruction::TimedInstruction{
+			time:integer::Time::ZERO,
+			instruction:strafesnet_common::physics::Instruction::Idle,
 		};
 		worker.send(task).unwrap();
+
+		//assert_eq!(test_body,worker.grab_clone());
+
+		// wait long enough to see print from final task
+		thread::sleep(std::time::Duration::from_millis(10));
 	}
-
-	// Optional: Signal the worker to stop (in a real-world scenario)
-	// sender.send("STOP".to_string()).unwrap();
-
-	// Sleep to allow the worker thread to finish processing
-	thread::sleep(std::time::Duration::from_millis(10));
-
-	// Send a new task
-	let task = crate::instruction::TimedInstruction{
-		time:crate::integer::Time::ZERO,
-		instruction:crate::physics::PhysicsInstruction::StrafeTick,
-	};
-	worker.send(task).unwrap();
-
-	//assert_eq!(test_body,worker.grab_clone());
-
-	// wait long enough to see print from final task
-	thread::sleep(std::time::Duration::from_millis(10));
 }

src/zeroes.rs

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

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/iso

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client bhop_maps/5692124338.snfm

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