fix fix

.cargo/config.toml

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

.gitignore

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

Cargo.toml

@@ -1,36 +1,27 @@
 [package]
 name = "strafe-client"
-version = "0.10.5"
+version = "0.8.0"
 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.29.0"
-id = { version = "0.1.0", registry = "strafesnet" }
+glam = "0.24.1"
+lazy-regex = "3.0.2"
+obj = "0.10.2"
 parking_lot = "0.12.1"
 pollster = "0.3.0"
-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"
+rbx_binary = "0.7.1"
+rbx_dom_weak = "2.5.0"
+rbx_reflection_database = "0.2.7"
+rbx_xml = "0.13.1"
+wgpu = "0.17.0"
+winit = { version = "0.29.2", features = ["rwh_05"] }
 
-[profile.release]
+#[profile.release]
 #lto = true
-strip = true
-codegen-units = 1
+#strip = true
+#codegen-units = 1

LICENSE

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

src/aabb.rs

@@ -0,0 +1,89 @@
+use crate::integer::Planar64Vec3;
+
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub enum AabbFace{
+	Right,//+X
+	Top,
+	Back,
+	Left,
+	Bottom,
+	Front,
+}
+#[derive(Clone)]
+pub struct Aabb{
+	pub min:Planar64Vec3,
+	pub max:Planar64Vec3,
+}
+
+impl Default for Aabb {
+	fn default()->Self {
+		Self{min:Planar64Vec3::MAX,max:Planar64Vec3::MIN}
+	}
+}
+
+impl Aabb{
+	const VERTEX_DATA:[Planar64Vec3;8]=[
+		Planar64Vec3::int( 1,-1,-1),
+		Planar64Vec3::int( 1, 1,-1),
+		Planar64Vec3::int( 1, 1, 1),
+		Planar64Vec3::int( 1,-1, 1),
+		Planar64Vec3::int(-1,-1, 1),
+		Planar64Vec3::int(-1, 1, 1),
+		Planar64Vec3::int(-1, 1,-1),
+		Planar64Vec3::int(-1,-1,-1),
+	];
+
+	pub fn grow(&mut self,point:Planar64Vec3){
+		self.min=self.min.min(point);
+		self.max=self.max.max(point);
+	}
+	pub fn join(&mut self,aabb:&Aabb){
+		self.min=self.min.min(aabb.min);
+		self.max=self.max.max(aabb.max);
+	}
+	pub fn inflate(&mut self,hs:Planar64Vec3){
+		self.min-=hs;
+		self.max+=hs;
+	}
+	pub fn intersects(&self,aabb:&Aabb)->bool{
+		(self.min.cmplt(aabb.max)&aabb.min.cmplt(self.max)).all()
+	}
+	pub fn normal(face:AabbFace)->Planar64Vec3{
+		match face {
+			AabbFace::Right=>Planar64Vec3::int(1,0,0),
+			AabbFace::Top=>Planar64Vec3::int(0,1,0),
+			AabbFace::Back=>Planar64Vec3::int(0,0,1),
+			AabbFace::Left=>Planar64Vec3::int(-1,0,0),
+			AabbFace::Bottom=>Planar64Vec3::int(0,-1,0),
+			AabbFace::Front=>Planar64Vec3::int(0,0,-1),
+		}
+	}
+	pub fn unit_vertices()->[Planar64Vec3;8] {
+		return Self::VERTEX_DATA;
+	}
+	// pub fn face(&self,face:AabbFace)->Aabb {
+	// 	let mut aabb=self.clone();
+	// 	//in this implementation face = worldspace aabb face
+	// 	match face {
+	// 		AabbFace::Right => aabb.min.x=aabb.max.x,
+	// 		AabbFace::Top => aabb.min.y=aabb.max.y,
+	// 		AabbFace::Back => aabb.min.z=aabb.max.z,
+	// 		AabbFace::Left => aabb.max.x=aabb.min.x,
+	// 		AabbFace::Bottom => aabb.max.y=aabb.min.y,
+	// 		AabbFace::Front => aabb.max.z=aabb.min.z,
+	// 	}
+	// 	return aabb;
+	// }
+	pub fn center(&self)->Planar64Vec3{
+		return self.min.midpoint(self.max)
+	}
+	//probably use floats for area & volume because we don't care about precision
+	// pub fn area_weight(&self)->f32{
+	// 	let d=self.max-self.min;
+	// 	d.x*d.y+d.y*d.z+d.z*d.x
+	// }
+	// pub fn volume(&self)->f32{
+	// 	let d=self.max-self.min;
+	// 	d.x*d.y*d.z
+	// }
+}

src/bvh.rs

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

src/compat_worker.rs

@@ -3,11 +3,11 @@ pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
 
 pub struct CompatNWorker<'a,Task>{
 	data:std::marker::PhantomData<Task>,
-	f:Box<dyn FnMut(Task)+Send+'a>,
+	f:Box<dyn FnMut(Task)+'a>,
 }
 
 impl<'a,Task> CompatNWorker<'a,Task>{
-	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+'a)->CompatNWorker<'a,Task>{
 		Self{
 			data:std::marker::PhantomData,
 			f:Box::new(f),

src/face_crawler.rs

@@ -1,127 +0,0 @@
-use crate::physics::Body;
-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>,GigaTime),
-	Hit(F,GigaTime),
-}
-
-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_transition=MinkowskiTransition::Miss;
-		match fev{
-			&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 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;
-					}
-				}
-				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).iter(){
-					let edge_n=mesh.directed_edge_n(directed_edge_id);
-					let n=n.cross(edge_n);
-					let verts=mesh.edge_verts(directed_edge_id.as_undirected());
-					//WARNING: d is moved out of the *2 block because of adding two vertices!
-					//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:
-			},
-			&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);
-				let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
-				for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
-					let face_n=mesh.face_nd(edge_face_id).0;
-					//edge_n gets parity from the order of edge_faces
-					let n=face_n.cross(edge_n)*((i as i64)*2-1);
-					//WARNING yada yada d *2
-					for 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;
-						}
-					}
-				}
-				//test each vertex collision time, ignoring roots with zero or conflicting derivative
-				for (i,&vert_id) in edge_verts.iter().enumerate(){
-					//vertex normal gets parity from vert index
-					let n=edge_n*(1-2*(i as i64));
-					for 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:
-			},
-			&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 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;
-						}
-					}
-				}
-				//if none:
-			},
-		}
-		best_transition
-	}
-pub enum CrawlResult<F,E:DirectedEdge,V>{
-	Miss(FEV<F,E,V>),
-	Hit(F,GigaTime),
-}
-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,body_time,mesh,relative_body,time_limit){
-			Transition::Miss=>return CrawlResult::Miss(fev),
-			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...");
-	CrawlResult::Miss(fev)
-}

src/file.rs

@@ -1,144 +0,0 @@
-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,8 +1,9 @@
 pub enum Instruction{
-	Render(crate::graphics::FrameState),
-	//UpdateModel(crate::graphics::GraphicsModelUpdate),
+	Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
+	//UpdateModel(crate::graphics::ModelUpdate),
 	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
-	ChangeMap(strafesnet_common::map::CompleteMap),
+	GenerateModels(crate::model::IndexedModelInstances),
+	ClearModels,
 }
 
 //Ideally the graphics thread worker description is:
@@ -17,30 +18,26 @@ WorkerDescription{
 pub fn new<'a>(
 		mut graphics:crate::graphics::GraphicsState,
 		mut config:wgpu::SurfaceConfiguration,
-	surface:wgpu::Surface<'a>,
+		surface:wgpu::Surface,
 		device:wgpu::Device,
 		queue:wgpu::Queue,
-)->crate::compat_worker::INWorker<'a,Instruction>{
-	let mut resize=None;
+	)->crate::compat_worker::INWorker<'a,Instruction>{
 	crate::compat_worker::INWorker::new(move |ins:Instruction|{
 		match ins{
-			Instruction::ChangeMap(map)=>{
+			Instruction::GenerateModels(indexed_model_instances)=>{
+				graphics.generate_models(&device,&queue,indexed_model_instances);
+			},
+			Instruction::ClearModels=>{
 				graphics.clear();
-				graphics.generate_models(&device,&queue,&map);
 			},
 			Instruction::Resize(size,user_settings)=>{
-				resize=Some((size,user_settings));
-			}
-			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);
-					println!("Resize took {:?}",t0.elapsed());
 			}
+			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
 				//this has to go deeper somehow
 				let frame=match surface.get_current_texture(){
 					Ok(frame)=>frame,
@@ -56,7 +53,7 @@ pub fn new<'a>(
 					..wgpu::TextureViewDescriptor::default()
 				});
 
-				graphics.render(&view,&device,&queue,frame_state);
+				graphics.render(&view,&device,&queue,physics_output,predicted_time,mouse_pos);
 
 				frame.present();
 			}

src/instruction.rs

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

src/integer.rs

@@ -0,0 +1,958 @@
+//integer units
+#[derive(Clone,Copy,Hash,PartialEq,PartialOrd,Debug)]
+pub struct Time(i64);
+impl Time{
+	pub const ZERO:Self=Self(0);
+	pub const ONE_SECOND:Self=Self(1_000_000_000);
+	pub const ONE_MILLISECOND:Self=Self(1_000_000);
+	pub const ONE_MICROSECOND:Self=Self(1_000);
+	pub const ONE_NANOSECOND:Self=Self(1);
+	#[inline]
+	pub fn from_secs(num:i64)->Self{
+		Self(Self::ONE_SECOND.0*num)
+	}
+	#[inline]
+	pub fn from_millis(num:i64)->Self{
+		Self(Self::ONE_MILLISECOND.0*num)
+	}
+	#[inline]
+	pub fn from_micros(num:i64)->Self{
+		Self(Self::ONE_MICROSECOND.0*num)
+	}
+	#[inline]
+	pub fn from_nanos(num:i64)->Self{
+		Self(Self::ONE_NANOSECOND.0*num)
+	}
+	//should I have checked subtraction? force all time variables to be positive?
+	#[inline]
+	pub fn nanos(&self)->i64{
+		self.0
+	}
+}
+impl From<Planar64> for Time{
+	#[inline]
+	fn from(value:Planar64)->Self{
+		Time((((value.0 as i128)*1_000_000_000)>>32) as i64)
+	}
+}
+impl std::fmt::Display for Time{
+	#[inline]
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
+	}
+}
+impl std::default::Default for Time{
+	fn default()->Self{
+		Self(0)
+	}
+}
+impl std::ops::Neg for Time{
+	type Output=Time;
+	#[inline]
+	fn neg(self)->Self::Output {
+		Time(-self.0)
+	}
+}
+impl std::ops::Add<Time> for Time{
+	type Output=Time;
+	#[inline]
+	fn add(self,rhs:Self)->Self::Output {
+		Time(self.0+rhs.0)
+	}
+}
+impl std::ops::Sub<Time> for Time{
+	type Output=Time;
+	#[inline]
+	fn sub(self,rhs:Self)->Self::Output {
+		Time(self.0-rhs.0)
+	}
+}
+impl std::ops::Mul<Time> for Time{
+	type Output=Time;
+	#[inline]
+	fn mul(self,rhs:Time)->Self::Output{
+		Self((((self.0 as i128)*(rhs.0 as i128))/1_000_000_000) as i64)
+	}
+}
+impl std::ops::Div<i64> for Time{
+	type Output=Time;
+	#[inline]
+	fn div(self,rhs:i64)->Self::Output {
+		Time(self.0/rhs)
+	}
+}
+
+#[inline]
+const fn gcd(mut a:u64,mut b:u64)->u64{
+	while b!=0{
+		(a,b)=(b,a.rem_euclid(b));
+	};
+	a
+}
+#[derive(Clone,Hash)]
+pub struct Ratio64{
+	num:i64,
+	den:u64,
+}
+impl Ratio64{
+	pub const ZERO:Self=Ratio64{num:0,den:1};
+	pub const ONE:Self=Ratio64{num:1,den:1};
+	#[inline]
+	pub const fn new(num:i64,den:u64)->Option<Ratio64>{
+		if den==0{
+			None
+		}else{
+			let d=gcd(num.unsigned_abs(),den);
+			Some(Self{num:num/d as i64,den:den/d})
+		}
+	}
+	#[inline]
+	pub fn mul_int(&self,rhs:i64)->i64{
+		rhs*self.num/self.den as i64
+	}
+	#[inline]
+	pub fn rhs_div_int(&self,rhs:i64)->i64{
+		rhs*self.den as i64/self.num
+	}
+	#[inline]
+	pub fn mul_ref(&self,rhs:&Ratio64)->Ratio64{
+		let (num,den)=(self.num*rhs.num,self.den*rhs.den);
+		let d=gcd(num.unsigned_abs(),den);
+		Self{
+			num:num/d as i64,
+			den:den/d,
+		}
+	}
+}
+//from num_traits crate
+#[inline]
+fn integer_decode_f32(f: f32) -> (u64, i16, i8) {
+	let bits: u32 = f.to_bits();
+	let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 };
+	let mut exponent: i16 = ((bits >> 23) & 0xff) as i16;
+	let mantissa = if exponent == 0 {
+		(bits & 0x7fffff) << 1
+	} else {
+		(bits & 0x7fffff) | 0x800000
+	};
+	// Exponent bias + mantissa shift
+	exponent -= 127 + 23;
+	(mantissa as u64, exponent, sign)
+}
+#[inline]
+fn integer_decode_f64(f: f64) -> (u64, i16, i8) {
+	let bits: u64 = f.to_bits();
+	let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 };
+	let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
+	let mantissa = if exponent == 0 {
+		(bits & 0xfffffffffffff) << 1
+	} else {
+		(bits & 0xfffffffffffff) | 0x10000000000000
+	};
+	// Exponent bias + mantissa shift
+	exponent -= 1023 + 52;
+	(mantissa, exponent, sign)
+}
+#[derive(Debug)]
+pub enum Ratio64TryFromFloatError{
+	Nan,
+	Infinite,
+	Subnormal,
+	HighlyNegativeExponent(i16),
+	HighlyPositiveExponent(i16),
+}
+const MAX_DENOMINATOR:u128=u64::MAX as u128;
+#[inline]
+fn ratio64_from_mes((m,e,s):(u64,i16,i8))->Result<Ratio64,Ratio64TryFromFloatError>{
+	if e< -127{
+		//this can also just be zero
+		Err(Ratio64TryFromFloatError::HighlyNegativeExponent(e))
+	}else if e< -63{
+		//approximate input ratio within denominator limit
+		let mut target_num=m as u128;
+		let mut target_den=1u128<<-e;
+
+		let mut num=1;
+		let mut den=0;
+		let mut prev_num=0;
+		let mut prev_den=1;
+
+		while target_den!=0{
+			let whole=target_num/target_den;
+			(target_num,target_den)=(target_den,target_num-whole*target_den);
+			let new_num=whole*num+prev_num;
+			let new_den=whole*den+prev_den;
+			if MAX_DENOMINATOR<new_den{
+				break;
+			}else{
+				(prev_num,prev_den)=(num,den);
+				(num,den)=(new_num,new_den);
+			}
+		}
+
+		Ok(Ratio64::new(num as i64,den as u64).unwrap())
+	}else if e<0{
+		Ok(Ratio64::new((m as i64)*(s as i64),1<<-e).unwrap())
+	}else if (64-m.leading_zeros() as i16)+e<64{
+		Ok(Ratio64::new((m as i64)*(s as i64)*(1<<e),1).unwrap())
+	}else{
+		Err(Ratio64TryFromFloatError::HighlyPositiveExponent(e))
+	}
+}
+impl TryFrom<f32> for Ratio64{
+	type Error=Ratio64TryFromFloatError;
+	#[inline]
+	fn try_from(value:f32)->Result<Self,Self::Error>{
+		match value.classify(){
+			std::num::FpCategory::Nan=>Err(Self::Error::Nan),
+			std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
+			std::num::FpCategory::Zero=>Ok(Self::ZERO),
+			std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
+			std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f32(value)),
+		}
+	}
+}
+impl TryFrom<f64> for Ratio64{
+	type Error=Ratio64TryFromFloatError;
+	#[inline]
+	fn try_from(value:f64)->Result<Self,Self::Error>{
+		match value.classify(){
+			std::num::FpCategory::Nan=>Err(Self::Error::Nan),
+			std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
+			std::num::FpCategory::Zero=>Ok(Self::ZERO),
+			std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
+			std::num::FpCategory::Normal=>ratio64_from_mes(integer_decode_f64(value)),
+		}
+	}
+}
+impl std::ops::Mul<Ratio64> for Ratio64{
+	type Output=Ratio64;
+	#[inline]
+	fn mul(self,rhs:Ratio64)->Self::Output{
+		let (num,den)=(self.num*rhs.num,self.den*rhs.den);
+		let d=gcd(num.unsigned_abs(),den);
+		Self{
+			num:num/d as i64,
+			den:den/d,
+		}
+	}
+}
+impl std::ops::Mul<i64> for Ratio64{
+	type Output=Ratio64;
+	#[inline]
+	fn mul(self,rhs:i64)->Self::Output {
+		Self{
+			num:self.num*rhs,
+			den:self.den,
+		}
+	}
+}
+impl std::ops::Div<u64> for Ratio64{
+	type Output=Ratio64;
+	#[inline]
+	fn div(self,rhs:u64)->Self::Output {
+		Self{
+			num:self.num,
+			den:self.den*rhs,
+		}
+	}
+}
+#[derive(Clone,Hash)]
+pub struct Ratio64Vec2{
+	pub x:Ratio64,
+	pub y:Ratio64,
+}
+impl Ratio64Vec2{
+	pub const ONE:Self=Self{x:Ratio64::ONE,y:Ratio64::ONE};
+	#[inline]
+	pub fn new(x:Ratio64,y:Ratio64)->Self{
+		Self{x,y}
+	}
+	#[inline]
+	pub fn mul_int(&self,rhs:glam::I64Vec2)->glam::I64Vec2{
+		glam::i64vec2(
+			self.x.mul_int(rhs.x),
+			self.y.mul_int(rhs.y),
+		)
+	}
+}
+impl std::ops::Mul<i64> for Ratio64Vec2{
+	type Output=Ratio64Vec2;
+	#[inline]
+	fn mul(self,rhs:i64)->Self::Output {
+		Self{
+			x:self.x*rhs,
+			y:self.y*rhs,
+		}
+	}
+}
+
+///[-pi,pi) = [-2^31,2^31-1]
+#[derive(Clone,Copy,Hash)]
+pub struct Angle32(i32);
+impl Angle32{
+	pub const FRAC_PI_2:Self=Self(1<<30);
+	pub const PI:Self=Self(-1<<31);
+	#[inline]
+	pub fn wrap_from_i64(theta:i64)->Self{
+		//take lower bits
+		//note: this was checked on compiler explorer and compiles to 1 instruction!
+		Self(i32::from_ne_bytes(((theta&((1<<32)-1)) as u32).to_ne_bytes()))
+	}
+	#[inline]
+	pub fn clamp_from_i64(theta:i64)->Self{
+		//the assembly is a bit confusing for this, I thought it was checking the same thing twice
+		//but it's just checking and then overwriting the value for both upper and lower bounds.
+		Self(theta.clamp(i32::MIN as i64,i32::MAX as i64) as i32)
+	}
+	#[inline]
+	pub fn get(&self)->i32{
+		self.0
+	}
+	/// Clamps the value towards the midpoint of the range.
+	/// Note that theta_min can be larger than theta_max and it will wrap clamp the other way around
+	#[inline]
+	pub fn clamp(&self,theta_min:Self,theta_max:Self)->Self{
+		//((max-min as u32)/2 as i32)+min
+		let midpoint=((
+			u32::from_ne_bytes(theta_max.0.to_ne_bytes())
+			.wrapping_sub(u32::from_ne_bytes(theta_min.0.to_ne_bytes()))
+			/2
+		) as i32)//(u32::MAX/2) as i32 ALWAYS works
+		.wrapping_add(theta_min.0);
+		//(theta-mid).clamp(max-mid,min-mid)+mid
+		Self(
+			self.0.wrapping_sub(midpoint)
+			.max(theta_min.0.wrapping_sub(midpoint))
+			.min(theta_max.0.wrapping_sub(midpoint))
+			.wrapping_add(midpoint)
+		)
+	}
+	/*
+	#[inline]
+	pub fn cos(&self)->Unit32{
+		//TODO: fix this rounding towards 0
+		Unit32(unsafe{((self.0 as f64*ANGLE32_TO_FLOAT64_RADIANS).cos()*UNIT32_ONE_FLOAT64).to_int_unchecked()})
+	}
+	#[inline]
+	pub fn sin(&self)->Unit32{
+		//TODO: fix this rounding towards 0
+		Unit32(unsafe{((self.0 as f64*ANGLE32_TO_FLOAT64_RADIANS).sin()*UNIT32_ONE_FLOAT64).to_int_unchecked()})
+	}
+	*/
+}
+const ANGLE32_TO_FLOAT64_RADIANS:f64=std::f64::consts::PI/((1i64<<31) as f64);
+impl Into<f32> for Angle32{
+	#[inline]
+	fn into(self)->f32{
+		(self.0 as f64*ANGLE32_TO_FLOAT64_RADIANS) as f32
+	}
+}
+impl std::ops::Neg for Angle32{
+	type Output=Angle32;
+	#[inline]
+	fn neg(self)->Self::Output{
+		Angle32(self.0.wrapping_neg())
+	}
+}
+impl std::ops::Add<Angle32> for Angle32{
+	type Output=Angle32;
+	#[inline]
+	fn add(self,rhs:Self)->Self::Output {
+		Angle32(self.0.wrapping_add(rhs.0))
+	}
+}
+impl std::ops::Sub<Angle32> for Angle32{
+	type Output=Angle32;
+	#[inline]
+	fn sub(self,rhs:Self)->Self::Output {
+		Angle32(self.0.wrapping_sub(rhs.0))
+	}
+}
+impl std::ops::Mul<i32> for Angle32{
+	type Output=Angle32;
+	#[inline]
+	fn mul(self,rhs:i32)->Self::Output {
+		Angle32(self.0.wrapping_mul(rhs))
+	}
+}
+impl std::ops::Mul<Angle32> for Angle32{
+	type Output=Angle32;
+	#[inline]
+	fn mul(self,rhs:Self)->Self::Output {
+		Angle32(self.0.wrapping_mul(rhs.0))
+	}
+}
+
+/* Unit type unused for now, may revive it for map files
+///[-1.0,1.0] = [-2^30,2^30]
+pub struct Unit32(i32);
+impl Unit32{
+	#[inline]
+	pub fn as_planar64(&self) -> Planar64{
+		Planar64(4*(self.0 as i64))
+	}
+}
+const UNIT32_ONE_FLOAT64=((1<<30) as f64);
+///[-1.0,1.0] = [-2^30,2^30]
+pub struct Unit32Vec3(glam::IVec3);
+impl TryFrom<[f32;3]> for Unit32Vec3{
+	type Error=Unit32TryFromFloatError;
+	fn try_from(value:[f32;3])->Result<Self,Self::Error>{
+		Ok(Self(glam::ivec3(
+			Unit32::try_from(Planar64::try_from(value[0])?)?.0,
+			Unit32::try_from(Planar64::try_from(value[1])?)?.0,
+			Unit32::try_from(Planar64::try_from(value[2])?)?.0,
+		)))
+	}
+}
+*/
+
+///[-1.0,1.0] = [-2^32,2^32]
+#[derive(Clone,Copy,Hash,Eq,Ord,PartialEq,PartialOrd)]
+pub struct Planar64(i64);
+impl Planar64{
+	pub const ZERO:Self=Self(0);
+	pub const ONE:Self=Self(1<<32);
+	#[inline]
+	pub const fn int(num:i32)->Self{
+		Self(Self::ONE.0*num as i64)
+	}
+	#[inline]
+	pub const fn raw(num:i64)->Self{
+		Self(num)
+	}
+	#[inline]
+	pub const fn get(&self)->i64{
+		self.0
+	}
+	pub fn sqrt(&self)->Self{
+		Planar64(unsafe{(((self.0 as i128)<<32) as f64).sqrt().to_int_unchecked()})
+	}
+}
+const PLANAR64_ONE_FLOAT32:f32=(1u64<<32) as f32;
+const PLANAR64_CONVERT_TO_FLOAT32:f32=1.0/PLANAR64_ONE_FLOAT32;
+const PLANAR64_ONE_FLOAT64:f64=(1u64<<32) as f64;
+impl Into<f32> for Planar64{
+	#[inline]
+	fn into(self)->f32{
+		self.0 as f32*PLANAR64_CONVERT_TO_FLOAT32
+	}
+}
+impl From<Ratio64> for Planar64{
+	#[inline]
+	fn from(ratio:Ratio64)->Self{
+		Self((((ratio.num as i128)<<32)/ratio.den as i128) as i64)
+	}
+}
+#[derive(Debug)]
+pub enum Planar64TryFromFloatError{
+	Nan,
+	Infinite,
+	Subnormal,
+	HighlyNegativeExponent(i16),
+	HighlyPositiveExponent(i16),
+}
+#[inline]
+fn planar64_from_mes((m,e,s):(u64,i16,i8))->Result<Planar64,Planar64TryFromFloatError>{
+	let e32=e+32;
+	if e32<0&&(m>>-e32)==0{//shifting m will underflow to 0
+		Ok(Planar64::ZERO)
+		// println!("m{} e{} s{}",m,e,s);
+		// println!("f={}",(m as f64)*(2.0f64.powf(e as f64))*(s as f64));
+		// Err(Planar64TryFromFloatError::HighlyNegativeExponent(e))
+	}else if (64-m.leading_zeros() as i16)+e32<64{//shifting m will not overflow
+		if e32<0{
+			Ok(Planar64((m as i64)*(s as i64)>>-e32))
+		}else{
+			Ok(Planar64((m as i64)*(s as i64)<<e32))
+		}
+	}else{//if shifting m will overflow (prev check failed)
+		Err(Planar64TryFromFloatError::HighlyPositiveExponent(e))
+	}
+}
+impl TryFrom<f32> for Planar64{
+	type Error=Planar64TryFromFloatError;
+	#[inline]
+	fn try_from(value:f32)->Result<Self,Self::Error>{
+		match value.classify(){
+			std::num::FpCategory::Nan=>Err(Self::Error::Nan),
+			std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
+			std::num::FpCategory::Zero=>Ok(Self::ZERO),
+			std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
+			std::num::FpCategory::Normal=>planar64_from_mes(integer_decode_f32(value)),
+		}
+	}
+}
+impl TryFrom<f64> for Planar64{
+	type Error=Planar64TryFromFloatError;
+	#[inline]
+	fn try_from(value:f64)->Result<Self,Self::Error>{
+		match value.classify(){
+			std::num::FpCategory::Nan=>Err(Self::Error::Nan),
+			std::num::FpCategory::Infinite=>Err(Self::Error::Infinite),
+			std::num::FpCategory::Zero=>Ok(Self::ZERO),
+			std::num::FpCategory::Subnormal=>Err(Self::Error::Subnormal),
+			std::num::FpCategory::Normal=>planar64_from_mes(integer_decode_f64(value)),
+		}
+	}
+}
+impl std::fmt::Display for Planar64{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{:.3}",
+			Into::<f32>::into(*self),
+		)
+	}
+}
+impl std::ops::Neg for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn neg(self)->Self::Output{
+		Planar64(-self.0)
+	}
+}
+impl std::ops::Add<Planar64> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn add(self, rhs: Self) -> Self::Output {
+		Planar64(self.0+rhs.0)
+	}
+}
+impl std::ops::Sub<Planar64> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn sub(self, rhs: Self) -> Self::Output {
+		Planar64(self.0-rhs.0)
+	}
+}
+impl std::ops::Mul<i64> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn mul(self, rhs: i64) -> Self::Output {
+		Planar64(self.0*rhs)
+	}
+}
+impl std::ops::Mul<Planar64> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn mul(self, rhs: Self) -> Self::Output {
+		Planar64(((self.0 as i128*rhs.0 as i128)>>32) as i64)
+	}
+}
+impl std::ops::Mul<Time> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn mul(self,rhs:Time)->Self::Output{
+		Planar64(((self.0 as i128*rhs.0 as i128)/1_000_000_000) as i64)
+	}
+}
+impl std::ops::Div<i64> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn div(self, rhs: i64) -> Self::Output {
+		Planar64(self.0/rhs)
+	}
+}
+impl std::ops::Div<Planar64> for Planar64{
+	type Output=Planar64;
+	#[inline]
+	fn div(self, rhs: Planar64) -> Self::Output {
+		Planar64((((self.0 as i128)<<32)/rhs.0 as i128) as i64)
+	}
+}
+// impl PartialOrd<i64> for Planar64{
+// 	fn partial_cmp(&self, other: &i64) -> Option<std::cmp::Ordering> {
+// 		self.0.partial_cmp(other)
+// 	}
+// }
+
+
+///[-1.0,1.0] = [-2^32,2^32]
+#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
+pub struct Planar64Vec3(glam::I64Vec3);
+impl Planar64Vec3{
+	pub const ZERO:Self=Planar64Vec3(glam::I64Vec3::ZERO);
+	pub const ONE:Self=Self::int(1,1,1);
+	pub const X:Self=Self::int(1,0,0);
+	pub const Y:Self=Self::int(0,1,0);
+	pub const Z:Self=Self::int(0,0,1);
+	pub const NEG_X:Self=Self::int(-1,0,0);
+	pub const NEG_Y:Self=Self::int(0,-1,0);
+	pub const NEG_Z:Self=Self::int(0,0,-1);
+	pub const MIN:Self=Planar64Vec3(glam::I64Vec3::MIN);
+	pub const MAX:Self=Planar64Vec3(glam::I64Vec3::MAX);
+	#[inline]
+	pub const fn int(x:i32,y:i32,z:i32)->Self{
+		Self(glam::i64vec3((x as i64)<<32,(y as i64)<<32,(z as i64)<<32))
+	}
+	#[inline]
+	pub const fn raw(x:i64,y:i64,z:i64)->Self{
+		Self(glam::i64vec3(x,y,z))
+	}
+	#[inline]
+	pub fn x(&self)->Planar64{
+		Planar64(self.0.x)
+	}
+	#[inline]
+	pub fn y(&self)->Planar64{
+		Planar64(self.0.y)
+	}
+	#[inline]
+	pub fn z(&self)->Planar64{
+		Planar64(self.0.z)
+	}
+	#[inline]
+	pub fn min(&self,rhs:Self)->Self{
+		Self(glam::i64vec3(
+			self.0.x.min(rhs.0.x),
+			self.0.y.min(rhs.0.y),
+			self.0.z.min(rhs.0.z),
+		))
+	}
+	#[inline]
+	pub fn max(&self,rhs:Self)->Self{
+		Self(glam::i64vec3(
+			self.0.x.max(rhs.0.x),
+			self.0.y.max(rhs.0.y),
+			self.0.z.max(rhs.0.z),
+		))
+	}
+	#[inline]
+	pub fn midpoint(&self,rhs:Self)->Self{
+		Self((self.0+rhs.0)/2)
+	}
+	#[inline]
+	pub fn cmplt(&self,rhs:Self)->glam::BVec3{
+		self.0.cmplt(rhs.0)
+	}
+	#[inline]
+	pub fn dot(&self,rhs:Self)->Planar64{
+		Planar64(((
+			(self.0.x as i128)*(rhs.0.x as i128)+
+			(self.0.y as i128)*(rhs.0.y as i128)+
+			(self.0.z as i128)*(rhs.0.z as i128)
+		)>>32) as i64)
+	}
+	#[inline]
+	pub fn length(&self)->Planar64{
+		let radicand=(self.0.x as i128)*(self.0.x as i128)+(self.0.y as i128)*(self.0.y as i128)+(self.0.z as i128)*(self.0.z as i128);
+		Planar64(unsafe{(radicand as f64).sqrt().to_int_unchecked()})
+	}
+	#[inline]
+	pub fn with_length(&self,length:Planar64)->Self{
+		let radicand=(self.0.x as i128)*(self.0.x as i128)+(self.0.y as i128)*(self.0.y as i128)+(self.0.z as i128)*(self.0.z as i128);
+		let self_length:i128=unsafe{(radicand as f64).sqrt().to_int_unchecked()};
+		//self.0*length/self_length
+		Planar64Vec3(
+			glam::i64vec3(
+				((self.0.x as i128)*(length.0 as i128)/self_length) as i64,
+				((self.0.y as i128)*(length.0 as i128)/self_length) as i64,
+				((self.0.z as i128)*(length.0 as i128)/self_length) as i64,
+			)
+		)
+	}
+}
+impl Into<glam::Vec3> for Planar64Vec3{
+	#[inline]
+	fn into(self)->glam::Vec3{
+		glam::vec3(
+			self.0.x as f32,
+			self.0.y as f32,
+			self.0.z as f32,
+		)*PLANAR64_CONVERT_TO_FLOAT32
+	}
+}
+impl TryFrom<[f32;3]> for Planar64Vec3{
+	type Error=Planar64TryFromFloatError;
+	#[inline]
+	fn try_from(value:[f32;3])->Result<Self,Self::Error>{
+		Ok(Self(glam::i64vec3(
+			Planar64::try_from(value[0])?.0,
+			Planar64::try_from(value[1])?.0,
+			Planar64::try_from(value[2])?.0,
+		)))
+	}
+}
+impl TryFrom<glam::Vec3A> for Planar64Vec3{
+	type Error=Planar64TryFromFloatError;
+	#[inline]
+	fn try_from(value:glam::Vec3A)->Result<Self,Self::Error>{
+		Ok(Self(glam::i64vec3(
+			Planar64::try_from(value.x)?.0,
+			Planar64::try_from(value.y)?.0,
+			Planar64::try_from(value.z)?.0,
+		)))
+	}
+}
+impl std::fmt::Display for Planar64Vec3{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{:.3},{:.3},{:.3}",
+			Into::<f32>::into(self.x()),Into::<f32>::into(self.y()),Into::<f32>::into(self.z()),
+		)
+	}
+}
+impl std::ops::Neg for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn neg(self)->Self::Output{
+		Planar64Vec3(-self.0)
+	}
+}
+impl std::ops::Add<Planar64Vec3> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn add(self,rhs:Planar64Vec3) -> Self::Output {
+		Planar64Vec3(self.0+rhs.0)
+	}
+}
+impl std::ops::AddAssign<Planar64Vec3> for Planar64Vec3{
+	#[inline]
+	fn add_assign(&mut self,rhs:Planar64Vec3){
+		*self=*self+rhs
+	}
+}
+impl std::ops::Sub<Planar64Vec3> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn sub(self,rhs:Planar64Vec3) -> Self::Output {
+		Planar64Vec3(self.0-rhs.0)
+	}
+}
+impl std::ops::SubAssign<Planar64Vec3> for Planar64Vec3{
+	#[inline]
+	fn sub_assign(&mut self,rhs:Planar64Vec3){
+		*self=*self-rhs
+	}
+}
+impl std::ops::Mul<Planar64Vec3> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn mul(self, rhs: Planar64Vec3) -> Self::Output {
+		Planar64Vec3(glam::i64vec3(
+			(((self.0.x as i128)*(rhs.0.x as i128))>>32) as i64,
+			(((self.0.y as i128)*(rhs.0.y as i128))>>32) as i64,
+			(((self.0.z as i128)*(rhs.0.z as i128))>>32) as i64
+		))
+	}
+}
+impl std::ops::Mul<Planar64> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn mul(self, rhs: Planar64) -> Self::Output {
+		Planar64Vec3(glam::i64vec3(
+			(((self.0.x as i128)*(rhs.0 as i128))>>32) as i64,
+			(((self.0.y as i128)*(rhs.0 as i128))>>32) as i64,
+			(((self.0.z as i128)*(rhs.0 as i128))>>32) as i64
+		))
+	}
+}
+impl std::ops::Mul<i64> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn mul(self,rhs:i64)->Self::Output {
+		Planar64Vec3(glam::i64vec3(
+			self.0.x*rhs,
+			self.0.y*rhs,
+			self.0.z*rhs
+		))
+	}
+}
+impl std::ops::Mul<Time> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn mul(self,rhs:Time)->Self::Output{
+		Planar64Vec3(glam::i64vec3(
+			(((self.0.x as i128)*(rhs.0 as i128))/1_000_000_000) as i64,
+			(((self.0.y as i128)*(rhs.0 as i128))/1_000_000_000) as i64,
+			(((self.0.z as i128)*(rhs.0 as i128))/1_000_000_000) as i64
+		))
+	}
+}
+impl std::ops::Div<i64> for Planar64Vec3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn div(self,rhs:i64)->Self::Output{
+		Planar64Vec3(glam::i64vec3(
+			self.0.x/rhs,
+			self.0.y/rhs,
+			self.0.z/rhs,
+		))
+	}
+}
+
+///[-1.0,1.0] = [-2^32,2^32]
+#[derive(Clone,Copy)]
+pub struct Planar64Mat3{
+	x_axis:Planar64Vec3,
+	y_axis:Planar64Vec3,
+	z_axis:Planar64Vec3,
+}
+impl Default for Planar64Mat3{
+	#[inline]
+	fn default() -> Self {
+		Self{
+			x_axis:Planar64Vec3::X,
+			y_axis:Planar64Vec3::Y,
+			z_axis:Planar64Vec3::Z,
+		}
+	}
+}
+impl std::ops::Mul<Planar64Vec3> for Planar64Mat3{
+	type Output=Planar64Vec3;
+	#[inline]
+	fn mul(self,rhs:Planar64Vec3) -> Self::Output {
+		self.x_axis*rhs.x()
+		+self.y_axis*rhs.y()
+		+self.z_axis*rhs.z()
+	}
+}
+
+impl Planar64Mat3{
+	#[inline]
+	pub fn from_cols(x_axis:Planar64Vec3,y_axis:Planar64Vec3,z_axis:Planar64Vec3)->Self{
+		Self{
+			x_axis,
+			y_axis,
+			z_axis,
+		}
+	}
+	pub const fn int_from_cols_array(array:[i32;9])->Self{
+		Self{
+			x_axis:Planar64Vec3::int(array[0],array[1],array[2]),
+			y_axis:Planar64Vec3::int(array[3],array[4],array[5]),
+			z_axis:Planar64Vec3::int(array[6],array[7],array[8]),
+		}
+	}
+	#[inline]
+	pub fn from_rotation_yx(yaw:Angle32,pitch:Angle32)->Self{
+		let xtheta=yaw.0 as f64*ANGLE32_TO_FLOAT64_RADIANS;
+		let (xs,xc)=xtheta.sin_cos();
+		let (xc,xs)=(xc*PLANAR64_ONE_FLOAT64,xs*PLANAR64_ONE_FLOAT64);
+		let ytheta=pitch.0 as f64*ANGLE32_TO_FLOAT64_RADIANS;
+		let (ys,yc)=ytheta.sin_cos();
+		let (yc,ys)=(yc*PLANAR64_ONE_FLOAT64,ys*PLANAR64_ONE_FLOAT64);
+		//TODO: fix this rounding towards 0
+		let (xc,xs):(i64,i64)=(unsafe{xc.to_int_unchecked()},unsafe{xs.to_int_unchecked()});
+		let (yc,ys):(i64,i64)=(unsafe{yc.to_int_unchecked()},unsafe{ys.to_int_unchecked()});
+		Self::from_cols(
+			Planar64Vec3(glam::i64vec3(xc,0,-xs)),
+			Planar64Vec3(glam::i64vec3(((xs as i128*ys as i128)>>32) as i64,yc,((xc as i128*ys as i128)>>32) as i64)),
+			Planar64Vec3(glam::i64vec3(((xs as i128*yc as i128)>>32) as i64,-ys,((xc as i128*yc as i128)>>32) as i64)),
+		)
+	}
+	#[inline]
+	pub fn from_rotation_y(angle:Angle32)->Self{
+		let theta=angle.0 as f64*ANGLE32_TO_FLOAT64_RADIANS;
+		let (s,c)=theta.sin_cos();
+		let (c,s)=(c*PLANAR64_ONE_FLOAT64,s*PLANAR64_ONE_FLOAT64);
+		//TODO: fix this rounding towards 0
+		let (c,s):(i64,i64)=(unsafe{c.to_int_unchecked()},unsafe{s.to_int_unchecked()});
+		Self::from_cols(
+			Planar64Vec3(glam::i64vec3(c,0,-s)),
+			Planar64Vec3::Y,
+			Planar64Vec3(glam::i64vec3(s,0,c)),
+		)
+	}
+}
+impl Into<glam::Mat3> for Planar64Mat3{
+	#[inline]
+	fn into(self)->glam::Mat3{
+		glam::Mat3::from_cols(
+			self.x_axis.into(),
+			self.y_axis.into(),
+			self.z_axis.into(),
+		)
+	}
+}
+impl TryFrom<glam::Mat3A> for Planar64Mat3{
+	type Error=Planar64TryFromFloatError;
+	#[inline]
+	fn try_from(value:glam::Mat3A)->Result<Self,Self::Error>{
+		Ok(Self{
+			x_axis:Planar64Vec3::try_from(value.x_axis)?,
+			y_axis:Planar64Vec3::try_from(value.y_axis)?,
+			z_axis:Planar64Vec3::try_from(value.z_axis)?,
+		})
+	}
+}
+impl std::fmt::Display for Planar64Mat3{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}",
+			Into::<f32>::into(self.x_axis.x()),Into::<f32>::into(self.x_axis.y()),Into::<f32>::into(self.x_axis.z()),
+			Into::<f32>::into(self.y_axis.x()),Into::<f32>::into(self.y_axis.y()),Into::<f32>::into(self.y_axis.z()),
+			Into::<f32>::into(self.z_axis.x()),Into::<f32>::into(self.z_axis.y()),Into::<f32>::into(self.z_axis.z()),
+		)
+	}
+}
+impl std::ops::Div<i64> for Planar64Mat3{
+	type Output=Planar64Mat3;
+	#[inline]
+	fn div(self,rhs:i64)->Self::Output{
+		Planar64Mat3{
+			x_axis:self.x_axis/rhs,
+			y_axis:self.y_axis/rhs,
+			z_axis:self.z_axis/rhs,
+		}
+	}
+}
+
+///[-1.0,1.0] = [-2^32,2^32]
+#[derive(Clone,Copy,Default)]
+pub struct Planar64Affine3{
+	pub matrix3:Planar64Mat3,//includes scale above 1
+	pub translation:Planar64Vec3,
+}
+
+impl Planar64Affine3{
+	#[inline]
+	pub fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
+		Self{matrix3,translation}
+	}
+	#[inline]
+	pub fn transform_point3(&self,point:Planar64Vec3) -> Planar64Vec3{
+		Planar64Vec3(
+			self.translation.0
+			+(self.matrix3.x_axis*point.x()).0
+			+(self.matrix3.y_axis*point.y()).0
+			+(self.matrix3.z_axis*point.z()).0
+		)
+	}
+}
+impl Into<glam::Mat4> for Planar64Affine3{
+	#[inline]
+	fn into(self)->glam::Mat4{
+		glam::Mat4::from_cols_array(&[
+			self.matrix3.x_axis.0.x as f32,self.matrix3.x_axis.0.y as f32,self.matrix3.x_axis.0.z as f32,0.0,
+			self.matrix3.y_axis.0.x as f32,self.matrix3.y_axis.0.y as f32,self.matrix3.y_axis.0.z as f32,0.0,
+			self.matrix3.z_axis.0.x as f32,self.matrix3.z_axis.0.y as f32,self.matrix3.z_axis.0.z as f32,0.0,
+			self.translation.0.x as f32,self.translation.0.y as f32,self.translation.0.z as f32,PLANAR64_ONE_FLOAT32
+		])*PLANAR64_CONVERT_TO_FLOAT32
+	}
+}
+impl TryFrom<glam::Affine3A> for Planar64Affine3{
+	type Error=Planar64TryFromFloatError;
+	fn try_from(value: glam::Affine3A)->Result<Self, Self::Error> {
+		Ok(Self{
+			matrix3:Planar64Mat3::try_from(value.matrix3)?,
+			translation:Planar64Vec3::try_from(value.translation)?
+		})
+	}
+}
+impl std::fmt::Display for Planar64Affine3{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"translation: {:.3},{:.3},{:.3}\nmatrix3:\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}\n{:.3},{:.3},{:.3}",
+			Into::<f32>::into(self.translation.x()),Into::<f32>::into(self.translation.y()),Into::<f32>::into(self.translation.z()),
+			Into::<f32>::into(self.matrix3.x_axis.x()),Into::<f32>::into(self.matrix3.x_axis.y()),Into::<f32>::into(self.matrix3.x_axis.z()),
+			Into::<f32>::into(self.matrix3.y_axis.x()),Into::<f32>::into(self.matrix3.y_axis.y()),Into::<f32>::into(self.matrix3.y_axis.z()),
+			Into::<f32>::into(self.matrix3.z_axis.x()),Into::<f32>::into(self.matrix3.z_axis.y()),Into::<f32>::into(self.matrix3.z_axis.z()),
+		)
+	}
+}
+
+#[test]
+fn test_sqrt(){
+	let r=Planar64::int(400);
+	println!("r{}",r.get());
+	let s=r.sqrt();
+	println!("s{}",s.get());
+}

src/load_roblox.rs

@@ -0,0 +1,496 @@
+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){
+	for &referent in instance.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
+			}
+			recursive_collect_superclass(objects,dom,c,superclass);
+		}
+	}
+}
+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,current: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});
+		},
+		"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"),
+				}
+			}
+		}
+	}
+	//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,
+	Part(RobloxPartDescription),
+	Cylinder,
+	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);
+
+				//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}))
+					},
+					"UnorderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::UnorderedCheckpoint(crate::model::TempAttrUnorderedCheckpoint{mode_id:0})),
+					other=>{
+						let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|OrderedCheckpoint|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()})),
+								"OrderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::OrderedCheckpoint(crate::model::TempAttrOrderedCheckpoint{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()})),
+								"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
+								_=>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!");
+						}
+					},
+					"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,
+					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder,
+					//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=>primitives::unit_sphere(),
+						RobloxBasePartDescription::Part(part_texture_description)=>{
+							let mut cube_face_description=primitives::CubeFaceDescription::new();
+							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::Cylinder=>primitives::unit_cylinder(),
+						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
+							let mut wedge_face_description=primitives::WedgeFaceDescription::new();
+							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::new();
+							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,17 +1,124 @@
-mod file;
+mod bvh;
+mod aabb;
+mod model;
 mod setup;
 mod window;
 mod worker;
+mod zeroes;
+mod integer;
 mod physics;
 mod graphics;
 mod settings;
-mod face_crawler;
+mod primitives;
+mod instruction;
+mod load_roblox;
 mod compat_worker;
-mod model_physics;
 mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
 
-fn main(){
-	setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
+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"=>Some(load_bsp::generate_indexed_models(input)),
+				//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.append(&mut model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap(),glam::Vec4::ONE));
+	indexed_models.push(primitives::unit_sphere());
+	indexed_models.push(primitives::unit_cylinder());
+	indexed_models.push(primitives::unit_cube());
+	println!("models.len = {:?}", indexed_models.len());
+	indexed_models[0].instances.push(model::ModelInstance{
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(10.,0.,-10.))).unwrap(),
+		..Default::default()
+	});
+	//quad monkeys
+	indexed_models[1].instances.push(model::ModelInstance{
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(10.,5.,10.))).unwrap(),
+		..Default::default()
+	});
+	indexed_models[1].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[1].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[1].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[1].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[2].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[3].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
 }

src/model.rs

@@ -0,0 +1,294 @@
+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{
+	pub start:usize,//start=model_id
+	pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
+	pub ordered_checkpoints:Vec<usize>,//ordered_checkpoints[checkpoint_id]=model_id
+	pub unordered_checkpoints:Vec<usize>,//unordered_checkpoints[checkpoint_id]=model_id
+	pub spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
+	pub 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)?)
+	}
+	pub fn get_ordered_checkpoint_model_id(&self,checkpoint_id:u32)->Option<&usize>{
+		self.ordered_checkpoints.get(*self.ordered_checkpoint_from_checkpoint_id.get(&checkpoint_id)?)
+	}
+}
+//I don't want this code to exist!
+#[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 TempAttrOrderedCheckpoint{
+	pub mode_id:u32,
+	pub checkpoint_id:u32,
+}
+#[derive(Clone)]
+pub struct TempAttrUnorderedCheckpoint{
+	pub mode_id:u32,
+}
+#[derive(Clone)]
+pub struct TempAttrWormhole{
+	pub wormhole_id:u32,
+}
+pub enum TempIndexedAttributes{
+	Start(TempAttrStart),
+	Spawn(TempAttrSpawn),
+	OrderedCheckpoint(TempAttrOrderedCheckpoint),
+	UnorderedCheckpoint(TempAttrUnorderedCheckpoint),
+	Wormhole(TempAttrWormhole),
+}
+
+//you have this effect while in contact
+#[derive(Clone)]
+pub struct ContactingLadder{
+	pub sticky:bool
+}
+#[derive(Clone)]
+pub enum ContactingBehaviour{
+    Surf,
+    Ladder(ContactingLadder),
+    Elastic(u32),//[1/2^32,1] 0=None (elasticity+1)/2^32
+}
+//you have this effect while intersecting
+#[derive(Clone)]
+pub struct IntersectingWater{
+	pub viscosity:Planar64,
+	pub density:Planar64,
+	pub current:Planar64Vec3,
+}
+//All models can be given these attributes
+#[derive(Clone)]
+pub struct GameMechanicAccelerator{
+	pub acceleration:Planar64Vec3
+}
+#[derive(Clone)]
+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)]
+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)]
+pub enum GameMechanicSetTrajectory{
+	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
+	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
+	},
+	TrajectoryTargetPoint{//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
+	DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
+}
+#[derive(Clone)]
+pub enum ZoneBehaviour{
+	//Start is indexed
+	//Checkpoints are indexed
+	Finish,
+	Anitcheat,
+}
+#[derive(Clone)]
+pub struct GameMechanicZone{
+	pub mode_id:u32,
+	pub behaviour:ZoneBehaviour,
+}
+// enum TrapCondition{
+// 	FasterThan(Planar64),
+// 	SlowerThan(Planar64),
+// 	InRange(Planar64,Planar64),
+// 	OutsideRange(Planar64,Planar64),
+// }
+#[derive(Clone)]
+pub enum StageElementBehaviour{
+ 	//Spawn,//The behaviour of stepping on a spawn setting the spawnid
+ 	SpawnAt,
+ 	Trigger,
+ 	Teleport,
+ 	Platform,
+ 	JumpLimit(u32),
+ 	//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
+}
+#[derive(Clone)]
+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)]
+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)]
+pub enum TeleportBehaviour{
+	StageElement(GameMechanicStageElement),
+	Wormhole(GameMechanicWormhole),
+}
+//attributes listed in order of handling
+#[derive(Default,Clone)]
+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.booster.is_some()
+		||self.trajectory.is_some()
+		||self.zone.is_some()
+		||self.teleport_behaviour.is_some()
+		||self.accelerator.is_some()
+	}
+}
+#[derive(Default,Clone)]
+pub struct ContactingAttributes{
+	//friction?
+	pub contact_behaviour:Option<ContactingBehaviour>,
+}
+impl ContactingAttributes{
+	pub fn any(&self)->bool{
+		self.contact_behaviour.is_some()
+	}
+}
+#[derive(Default,Clone)]
+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,48 +1,55 @@
-use bytemuck::{Pod,Zeroable};
-use strafesnet_common::model::{IndexedVertex,PolygonGroup,RenderConfigId};
-#[derive(Clone,Copy,Pod,Zeroable)]
+use bytemuck::{Pod, Zeroable};
+use crate::model::{IndexedVertex,IndexedPolygon};
+#[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],
 }
-#[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 struct IndexedGroupFixedTexture{
+	pub polys:Vec<IndexedPolygon>,
+}
+pub struct IndexedModelGraphicsSingleTexture{
+	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 render_config:RenderConfigId,
-	pub polys:PolygonGroup,
-	pub instances:Vec<GraphicsModelOwned>,
+	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
+	pub groups: Vec<IndexedGroupFixedTexture>,
+	pub instances:Vec<ModelGraphicsInstance>,
 }
-pub enum Indices{
-	U32(Vec<u32>),
-	U16(Vec<u16>),
+pub struct ModelGraphicsSingleTexture{
+	pub instances: Vec<ModelGraphicsInstance>,
+	pub vertices: Vec<GraphicsVertex>,
+	pub entities: Vec<Vec<u16>>,
+	pub texture: Option<u32>,
 }
-pub struct GraphicsMeshOwnedRenderConfig{
-	pub vertices:Vec<GraphicsVertex>,
-	pub indices:Indices,
-	pub render_config:RenderConfigId,
-	pub instances:Vec<GraphicsModelOwned>,
+#[derive(Clone,PartialEq)]
+pub struct ModelGraphicsColor4(glam::Vec4);
+impl ModelGraphicsColor4{
+	pub const fn get(&self)->glam::Vec4{
+		self.0
+	}
 }
-#[derive(Clone,Copy,PartialEq,id::Id)]
-pub struct GraphicsModelColor4(glam::Vec4);
-impl std::hash::Hash for GraphicsModelColor4{
-	fn hash<H:std::hash::Hasher>(&self,state:&mut H) {
+impl From<glam::Vec4> for ModelGraphicsColor4{
+	fn from(value:glam::Vec4)->Self{
+		Self(value)
+	}
+}
+impl std::hash::Hash for ModelGraphicsColor4{
+	fn hash<H: std::hash::Hasher>(&self,state:&mut H) {
 		for &f in self.0.as_ref(){
 			bytemuck::cast::<f32,u32>(f).hash(state);
 		}
 	}
 }
-impl Eq for GraphicsModelColor4{}
+impl Eq for ModelGraphicsColor4{}
 #[derive(Clone)]
-pub struct GraphicsModelOwned{
+pub struct ModelGraphicsInstance{
 	pub transform:glam::Mat4,
 	pub normal_transform:glam::Mat3,
-	pub color:GraphicsModelColor4,
+	pub color:ModelGraphicsColor4,
 }

src/physics_worker.rs

@@ -1,12 +1,8 @@
-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;
-
+use crate::integer::Time;
+use crate::physics::{MouseState,PhysicsInputInstruction};
+use crate::instruction::{TimedInstruction,InstructionConsumer};
 #[derive(Debug)]
-pub enum InputInstruction{
+pub enum InputInstruction {
 	MoveMouse(glam::IVec2),
 	MoveRight(bool),
 	MoveUp(bool),
@@ -16,148 +12,82 @@ pub enum InputInstruction{
 	MoveForward(bool),
 	Jump(bool),
 	Zoom(bool),
-	ResetAndRestart,
-	ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId,strafesnet_common::gameplay_modes::StageId),
-	PracticeFly,
+	Reset,
 }
 pub enum Instruction{
 	Input(InputInstruction),
 	Render,
-	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),
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
+	GenerateModels(crate::model::IndexedModelInstances),
+	ClearModels,
 	//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,
 
-}
-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{
+	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
-			self.timeline.push_front(TimedInstruction{
-				time:self.last_mouse_time,
-				instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:self.timer.time(ins.time),pos:m}),
+							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
-			self.timeline.push_front(TimedInstruction{
-				time:self.last_mouse_time,
+							timeline.push_front(TimedInstruction{
+								time: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}
+									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
-			self.mouse_blocking=true;
+							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),
+						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,
 				});
-	}
-	/// 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{
+				
+				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)<self.timer.time(time)-self.physics.get_next_mouse().time{
-				self.unblock_mouse(time);
+					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
@@ -165,78 +95,39 @@ impl MouseInterpolator{
 				}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);
+					last_mouse_time=ins.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,
-			)),
+			}else{
+				//mouse event
+				true
+			}{
+				//empty queue
+				while let Some(instruction)=timeline.pop_front(){
+					physics.run(instruction.time);
+					physics.process_instruction(TimedInstruction{
+						time:instruction.time,
+						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
 					});
 				}
-	pub 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();
+					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
 				},
-			Instruction::Resize(size)=>{
-				graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,interpolator.user_settings().clone())).unwrap();
+				Instruction::Resize(size,user_settings)=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
 				},
-			Instruction::ChangeMap(map)=>{
-				interpolator.change_map(ins.time,&map);
-				graphics_worker.send(crate::graphics_worker::Instruction::ChangeMap(map)).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::Input(_)=>(),
-			Instruction::SetPaused(_)=>(),
+				Instruction::ClearModels=>{
+					physics.clear();
+					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
+				},
+				_=>(),
 			}
 		})
-}
+	}

src/primitives.rs

@@ -0,0 +1,510 @@
+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
+];
+//HashMap fits this use case perfectly but feels like using a sledgehammer to drive a nail
+pub fn unit_sphere()->crate::model::IndexedModel{
+	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),Color4::ONE).remove(0);
+	for pos in indexed_model.unique_pos.iter_mut(){
+		*pos=*pos/2;
+	}
+	indexed_model
+}
+pub type CubeFaceDescription=std::collections::HashMap::<CubeFace,FaceDescription>;
+pub fn unit_cube()->crate::model::IndexedModel{
+	let mut t=CubeFaceDescription::new();
+	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)
+}
+const TEAPOT_TRANSFORM:crate::integer::Planar64Mat3=crate::integer::Planar64Mat3::int_from_cols_array([0,1,0, -1,0,0, 0,0,1]);
+pub fn unit_cylinder()->crate::model::IndexedModel{
+	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),Color4::ONE).remove(0);
+	for pos in indexed_model.unique_pos.iter_mut(){
+		*pos=TEAPOT_TRANSFORM*(*pos)/10;
+	}
+	indexed_model
+}
+pub type WedgeFaceDescription=std::collections::HashMap::<WedgeFace,FaceDescription>;
+pub fn unit_wedge()->crate::model::IndexedModel{
+	let mut t=WedgeFaceDescription::new();
+	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)
+}
+pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,FaceDescription>;
+pub fn unit_cornerwedge()->crate::model::IndexedModel{
+	let mut t=CornerWedgeFaceDescription::new();
+	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
+		}
+	}
+}
+impl FaceDescription{
+	pub fn new(texture:u32,transform:glam::Affine2,color:Color4)->Self{
+		Self{texture:Some(texture),transform,color}
+	}
+	pub fn from_texture(texture:u32)->Self{
+		Self{
+			texture:Some(texture),
+			transform:glam::Affine2::IDENTITY,
+			color:Color4::ONE,
+		}
+	}
+}
+//TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
+//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,face_description) in face_descriptions.into_iter(){
+		//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;
+		let face_id=match face{
+			CubeFace::Right => 0,
+			CubeFace::Top => 1,
+			CubeFace::Back => 2,
+			CubeFace::Left => 3,
+			CubeFace::Bottom => 4,
+			CubeFace::Front => 5,
+		};
+		//always push normal
+		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,face_description) in face_descriptions.into_iter(){
+		//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;
+		let face_id=match face{
+			WedgeFace::Right => 0,
+			WedgeFace::TopFront => 1,
+			WedgeFace::Back => 2,
+			WedgeFace::Left => 3,
+			WedgeFace::Bottom => 4,
+		};
+		//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,face_description) in face_descriptions.into_iter(){
+		//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;
+		let face_id=match face{
+			CornerWedgeFace::Right => 0,
+			CornerWedgeFace::TopBack => 1,
+			CornerWedgeFace::TopLeft => 2,
+			CornerWedgeFace::Bottom => 3,
+			CornerWedgeFace::Front => 4,
+		};
+		//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 strafesnet_common::integer::{Ratio64,Ratio64Vec2};
+use crate::integer::{Ratio64,Ratio64Vec2};
 #[derive(Clone)]
 struct Ratio{
 	ratio:f64,

src/setup.rs

@@ -1,6 +1,5 @@
+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
@@ -25,14 +24,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 attr=winit::window::WindowAttributes::default();
-	attr=attr.with_title(title);
+	let mut builder = winit::window::WindowBuilder::new();
+	builder = builder.with_title(title);
 	#[cfg(windows_OFF)] // TODO
 	{
 		use winit::platform::windows::WindowBuilderExtWindows;
-		builder=builder.with_no_redirection_bitmap(true);
+		builder = builder.with_no_redirection_bitmap(true);
 	}
-	event_loop.create_window(attr)
+	builder.build(event_loop)
 }
 fn create_instance()->SetupContextPartial1{
 	let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
@@ -42,26 +41,25 @@ fn create_instance()->SetupContextPartial1{
 		instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
 			backends,
 			dx12_shader_compiler,
-			..Default::default()
 		}),
 	}
 }
 impl SetupContextPartial1{
-	fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
+	fn create_surface(self,window:&winit::window::Window)->Result<SetupContextPartial2,wgpu::CreateSurfaceError>{
 		Ok(SetupContextPartial2{
 			backends:self.backends,
-			surface:self.instance.create_surface(window)?,
+			surface:unsafe{self.instance.create_surface(window)}?,
 			instance:self.instance,
 		})
 	}
 }
-struct SetupContextPartial2<'a>{
+struct SetupContextPartial2{
 	backends:wgpu::Backends,
 	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
+	surface:wgpu::Surface,
 }
-impl<'a> SetupContextPartial2<'a>{
-	fn pick_adapter(self)->SetupContextPartial3<'a>{
+impl SetupContextPartial2{
+	fn pick_adapter(self)->SetupContextPartial3{
 		let adapter;
 
 		//TODO: prefer adapter that implements optional features
@@ -123,13 +121,13 @@ impl<'a> SetupContextPartial2<'a>{
 		}
 	}
 }
-struct SetupContextPartial3<'a>{
+struct SetupContextPartial3{
 	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
+	surface:wgpu::Surface,
 	adapter:wgpu::Adapter,
 }
-impl<'a> SetupContextPartial3<'a>{
-	fn request_device(self)->SetupContextPartial4<'a>{
+impl SetupContextPartial3{
+	fn request_device(self)->SetupContextPartial4{
 		let optional_features=optional_features();
 		let required_features=required_features();
 
@@ -141,9 +139,8 @@ impl<'a> SetupContextPartial3<'a>{
 			.request_device(
 				&wgpu::DeviceDescriptor {
 					label: None,
-					required_features: (optional_features & self.adapter.features()) | required_features,
-					required_limits: needed_limits,
-					memory_hints:wgpu::MemoryHints::Performance,
+					features: (optional_features & self.adapter.features()) | required_features,
+					limits: needed_limits,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
@@ -158,21 +155,20 @@ impl<'a> SetupContextPartial3<'a>{
 		}
 	}
 }
-struct SetupContextPartial4<'a>{
+struct SetupContextPartial4{
 	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
+	surface:wgpu::Surface,
 	adapter:wgpu::Adapter,
 	device:wgpu::Device,
 	queue:wgpu::Queue,
 }
-impl<'a> SetupContextPartial4<'a>{
-	fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
+impl SetupContextPartial4{
+	fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->SetupContext{
 		let mut config=self.surface
 			.get_default_config(&self.adapter, size.width, size.height)
 			.expect("Surface isn't supported by the adapter.");
 		let surface_view_format=config.format.add_srgb_suffix();
 		config.view_formats.push(surface_view_format);
-		config.present_mode=wgpu::PresentMode::AutoNoVsync;
 		self.surface.configure(&self.device, &config);
 
 		SetupContext{
@@ -184,52 +180,65 @@ impl<'a> SetupContextPartial4<'a>{
 		}
 	}
 }
-pub struct SetupContext<'a>{
+pub struct SetupContext{
 	pub instance:wgpu::Instance,
-	pub surface:wgpu::Surface<'a>,
+	pub surface:wgpu::Surface,
 	pub device:wgpu::Device,
 	pub queue:wgpu::Queue,
 	pub config:wgpu::SurfaceConfiguration,
 }
 
-pub fn setup_and_start(title:String){
+pub fn setup(title:&str)->SetupContextSetup{
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
+	let 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();
 
-	let size=window.inner_size();
+	SetupContextSetup{
+		window,
+		event_loop,
+		partial_context:partial_4,
+	}
+}
 
-	let setup_context=partial_4.configure_surface(&size);
+pub struct SetupContextSetup{
+	window:winit::window::Window,
+	event_loop:winit::event_loop::EventLoop<()>,
+	partial_context:SetupContextPartial4,
+}
+
+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
 
+		let window=crate::window::WindowContextSetup::new(&setup_context,window);
 		//the thread that spawns the physics thread
-	let mut window_thread=crate::window::worker(
-		&window,
-		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();
-	};
+		let window_thread=window.into_worker(setup_context);
 
 		println!("Entering event loop...");
 		let root_time=std::time::Instant::now();
 		run_event_loop(event_loop,window_thread,root_time).unwrap();
+	}
 }
 
 fn run_event_loop(
@@ -238,7 +247,7 @@ fn run_event_loop(
 	root_time:std::time::Instant
 	)->Result<(),winit::error::EventLoopError>{
 		event_loop.run(move |event,elwt|{
-			let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
+			let time=crate::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=512;
+const MAX_MODEL_INSTANCES=4096;
 @group(2)
 @binding(0)
 var<uniform> model_instances: array<ModelInstance, MAX_MODEL_INSTANCES>;

src/sweep.rs

@@ -0,0 +1,8 @@
+
+//something that implements body + hitbox + transform can predict collision
+impl crate::sweep::PredictCollision for Model {
+	fn predict_collision(&self,other:&Model) -> Option<crate::event::EventStruct> {
+		//math!
+		None
+	}
+}

src/window.rs

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

src/worker.rs

@@ -173,24 +173,19 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 	}
 }
 
-#[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() {
+#[test]//How to run this test with printing: cargo test --release -- --nocapture
+fn test_worker() {
+	println!("hiiiii");
 	// 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)
+	let worker=QRWorker::new(crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO),
+		|_|crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE)
 	);
 
 	// Send tasks to the worker
 	for _ in 0..5 {
-			let task = instruction::TimedInstruction{
-				time:integer::Time::ZERO,
-				instruction:strafesnet_common::physics::Instruction::Idle,
+		let task = crate::instruction::TimedInstruction{
+			time:crate::integer::Time::ZERO,
+			instruction:crate::physics::PhysicsInstruction::StrafeTick,
 		};
 		worker.send(task).unwrap();
 	}
@@ -199,18 +194,17 @@ mod test{
 	// sender.send("STOP".to_string()).unwrap();
 
 	// Sleep to allow the worker thread to finish processing
-		thread::sleep(std::time::Duration::from_millis(10));
+	thread::sleep(std::time::Duration::from_secs(2));
 
 	// Send a new task
-		let task = instruction::TimedInstruction{
-			time:integer::Time::ZERO,
-			instruction:strafesnet_common::physics::Instruction::Idle,
+	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());
+	println!("value={}",worker.grab_clone());
 
 	// wait long enough to see print from final task
-		thread::sleep(std::time::Duration::from_millis(10));
-	}
+	thread::sleep(std::time::Duration::from_secs(1));
 }

src/zeroes.rs

@@ -0,0 +1,33 @@
+//find roots of polynomials
+use crate::integer::Planar64;
+
+#[inline]
+pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64)->([Planar64;2],usize){
+	if a2==Planar64::ZERO{
+		let ([ret],ret_len)=zeroes1(a0,a1);
+		return ([ret,Planar64::ZERO],ret_len);
+	}
+	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
+		let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
+		//TODO: one or two newtons
+		if Planar64::ZERO<a2{
+			([(-a1-planar_radicand)/(a2*2),(-a1+planar_radicand)/(a2*2)],2)
+		}else{
+			([(-a1+planar_radicand)/(a2*2),(-a1-planar_radicand)/(a2*2)],2)
+		}
+	}else if radicand==0{
+		([a1/(a2*-2),Planar64::ZERO],1)
+	}else{
+		([Planar64::ZERO,Planar64::ZERO],0)
+	}
+}
+#[inline]
+pub fn zeroes1(a0:Planar64,a1:Planar64)->([Planar64;1],usize){
+	if a1==Planar64::ZERO{
+		return ([Planar64::ZERO],0);
+	}else{
+		return ([-a0/a1],1);
+	}
+}

tools/arcane

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

tools/bhop_maps

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

tools/cross-compile.sh

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

tools/iso

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

tools/make-demo.sh

@@ -1,4 +0,0 @@
-mkdir -p ../target/demo
-mv ../target/x86_64-pc-windows-gnu/release/strafe-client.exe ../target/demo/strafe-client.exe
-rm ../target/demo.7z
-7z a -t7z -mx=9 -mfb=273 -ms -md=31 -myx=9 -mtm=- -mmt -mmtf -md=1536m -mmf=bt3 -mmc=10000 -mpb=0 -mlc=0 ../target/demo.7z ../target/demo

tools/run

@@ -1 +0,0 @@
-mangohud ../target/release/strafe-client "$1"

tools/settings.conf

@@ -1,4 +0,0 @@
-[camera]
-sensitivity_x=98384
-fov_y=1.0
-#fov_x_from_y_ratio=1.33333333333333333333333333333333

tools/surf_maps

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

tools/toc

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

tools/utopia

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