runtime map loading!

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.9.0"
+version = "0.8.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -9,7 +9,7 @@ edition = "2021"
 bytemuck = { version = "1.13.1", features = ["derive"] }
 configparser = "3.0.2"
 ddsfile = "0.5.1"
-glam = "0.25.0"
+glam = "0.24.1"
 lazy-regex = "3.0.2"
 obj = "0.10.2"
 parking_lot = "0.12.1"
@@ -18,11 +18,8 @@ rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
-strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "434ca29aef7e3015c9ca1ed45de8fef42e33fdfb" }
-vbsp = "0.5.0"
-vmdl = "0.1.1"
-wgpu = "0.19.0"
-winit = "0.29.2"
+wgpu = "0.17.0"
+winit = { version = "0.29.2", features = ["rwh_05"] }
 
 #[profile.release]
 #lto = true

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,119 +0,0 @@
-use crate::physics::Body;
-use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
-use strafesnet_common::integer::{Time,Planar64};
-use strafesnet_common::zeroes::zeroes2;
-
-enum Transition<F,E:DirectedEdge,V>{
-	Miss,
-	Next(FEV<F,E,V>,Time),
-	Hit(F,Time),
-}
-
-	fn next_transition<F:Copy,E:Copy+DirectedEdge,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
-		//conflicting derivative means it crosses in the wrong direction.
-		//if the transition time is equal to an already tested transition, do not replace the current best.
-		let mut best_time=time_limit;
-		let mut best_transtition=Transition::Miss;
-		match fev{
-			&FEV::<F,E,V>::Face(face_id)=>{
-				//test own face collision time, ignoring roots with zero or conflicting derivative
-				//n=face.normal d=face.dot
-				//n.a t^2+n.v t+n.p-d==0
-				let (n,d)=mesh.face_nd(face_id);
-				//TODO: use higher precision d value?
-				//use the mesh transform translation instead of baking it into the d value.
-				for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					let t=body.time+Time::from(t);
-					if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-						best_time=t;
-						best_transtition=Transition::Hit(face_id,t);
-						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!
-					for t in zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))),n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
-							break;
-						}
-					}
-				}
-				//if none:
-			},
-			&FEV::<F,E,V>::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 t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
-							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 t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
-							break;
-						}
-					}
-				}
-				//if none:
-			},
-			&FEV::<F,E,V>::Vert(vert_id)=>{
-				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
-					//edge is directed away from vertex, but we want the dot product to turn out negative
-					let n=-mesh.directed_edge_n(directed_edge_id);
-					for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
-							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
-							break;
-						}
-					}
-				}
-				//if none:
-			},
-		}
-		best_transtition
-	}
-pub enum CrawlResult<F,E:DirectedEdge,V>{
-	Miss(FEV<F,E,V>),
-	Hit(F,Time),
-}
-pub fn crawl_fev<F:Copy,E:Copy+DirectedEdge,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>{	
-	let mut time=start_time;
-	for _ in 0..20{
-		match next_transition(&fev,time,mesh,relative_body,time_limit){
-			Transition::Miss=>return CrawlResult::Miss(fev),
-			Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
-			Transition::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/graphics.rs

@@ -1,10 +1,9 @@
 use std::borrow::Cow;
-use strafesnet_common::integer;
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
+use crate::model_graphics::{GraphicsVertex,ModelGraphicsColor4,ModelGraphicsInstance,ModelGraphicsSingleTexture,IndexedModelGraphicsSingleTexture,IndexedGroupFixedTexture};
 
 #[derive(Clone)]
-pub struct GraphicsModelUpdate{
+pub struct ModelUpdate{
 	transform:Option<glam::Mat4>,
 	color:Option<glam::Vec4>,
 }
@@ -13,27 +12,13 @@ struct Entity{
 	index_count: u32,
 	index_buf: wgpu::Buffer,
 }
-fn create_entities<T:bytemuck::Pod>(device:&wgpu::Device,entities:&Vec<Vec<T>>)->Vec<Entity>{
-	entities.iter().map(|indices|{
-		let index_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
-			label:Some("Index"),
-			contents:bytemuck::cast_slice(indices),
-			usage:wgpu::BufferUsages::INDEX,
-		});
-		Entity{
-			index_buf,
-			index_count:indices.len() as u32,
-		}
-	}).collect()
-}
 
-struct GraphicsModel{
-	entities:Vec<Entity>,
-	model_buf:wgpu::Buffer,
+struct ModelGraphics {
+	instances: Vec<ModelGraphicsInstance>,
 	vertex_buf: wgpu::Buffer,
+	entities: Vec<Entity>,
 	bind_group: wgpu::BindGroup,
-	index_format:wgpu::IndexFormat,
-	instances:Vec<GraphicsModelInstance>,
+	model_buf: wgpu::Buffer,
 }
 
 pub struct GraphicsSamplers{
@@ -72,6 +57,12 @@ fn perspective_rh(fov_x_slope: f32, fov_y_slope: f32, z_near: f32, z_far: f32) -
 	)
 }
 impl GraphicsCamera{
+	pub fn new(screen_size:glam::UVec2,fov:glam::Vec2)->Self{
+		Self{
+			screen_size,
+			fov,
+		}
+	}
 	pub fn proj(&self)->glam::Mat4{
 		perspective_rh(self.fov.x, self.fov.y, 0.5, 2000.0)
 	}
@@ -111,7 +102,7 @@ pub struct GraphicsState{
 	camera:GraphicsCamera,
 	camera_buf: wgpu::Buffer,
 	temp_squid_texture_view: wgpu::TextureView,
-	models: Vec<GraphicsModel>,
+	models: Vec<ModelGraphics>,
 	depth_view: wgpu::TextureView,
 	staging_belt: wgpu::util::StagingBelt,
 }
@@ -153,14 +144,11 @@ impl GraphicsState{
 		let mut texture_loading_threads=Vec::new();
 		let num_textures=indexed_models.textures.len();
 		for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
-			let path=std::path::PathBuf::from(format!("textures/{}.dds",texture_id));
-			if let Ok(mut file) = std::fs::File::open(path.clone()){
+			if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",texture_id))){
 				double_map.insert(i as u32, texture_loading_threads.len() as u32);
 				texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
 					ddsfile::Dds::read(&mut file).unwrap()
 				})));
-			}else{
-				//println!("missing texture path={:?}",path);
 			}
 		}
 
@@ -204,7 +192,6 @@ impl GraphicsState{
 					label: Some(format!("Texture{}",texture_id).as_str()),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&image.data,
 			);
 			texture.create_view(&wgpu::TextureViewDescriptor {
@@ -219,15 +206,15 @@ impl GraphicsState{
 		let indexed_models_len=indexed_models.models.len();
 		let mut unique_texture_models=Vec::with_capacity(indexed_models_len);
 		for model in indexed_models.models.into_iter(){
-			//convert ModelInstance into GraphicsModelInstance
-			let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
-				if instance.color.w==0.0&&!model.groups.iter().any(|g|g.texture.is_some()){
+			//convert ModelInstance into ModelGraphicsInstance
+			let instances:Vec<ModelGraphicsInstance>=model.instances.into_iter().filter_map(|instance|{
+				if instance.color.w==0.0{
 					None
 				}else{
-					Some(GraphicsModelInstance{
+					Some(ModelGraphicsInstance{
 						transform: instance.transform.into(),
 						normal_transform: Into::<glam::Mat3>::into(instance.transform.matrix3).inverse().transpose(),
-						color:GraphicsModelColor4::from(instance.color),
+						color:ModelGraphicsColor4::from(instance.color),
 					})
 				}
 			}).collect();
@@ -246,7 +233,7 @@ impl GraphicsState{
 					//create new texture_index
 					let texture_index=unique_textures.len();
 					unique_textures.push(group.texture);
-					unique_texture_models.push(IndexedGraphicsModelSingleTexture{
+					unique_texture_models.push(IndexedModelGraphicsSingleTexture{
 						unique_pos:model.unique_pos.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
 						unique_tex:model.unique_tex.iter().map(|v|*v.as_ref()).collect(),
 						unique_normal:model.unique_normal.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
@@ -380,10 +367,10 @@ impl GraphicsState{
 						//creating the vertex map is slightly different because the vertices are directly hashable
 						let map_vertex_id:Vec<u32>=model.unique_vertices.iter().map(|unmapped_vertex|{
 							let vertex=crate::model::IndexedVertex{
-								pos:map_pos_id[unmapped_vertex.pos as usize],
-								tex:map_tex_id[unmapped_vertex.tex as usize],
-								normal:map_normal_id[unmapped_vertex.normal as usize],
-								color:map_color_id[unmapped_vertex.color as usize],
+								pos:map_pos_id[unmapped_vertex.pos as usize] as u32,
+								tex:map_tex_id[unmapped_vertex.tex as usize] as u32,
+								normal:map_normal_id[unmapped_vertex.normal as usize] as u32,
+								color:map_color_id[unmapped_vertex.color as usize] as u32,
 							};
 							(if let Some(&vertex_id)=vertex_id_from.get(&vertex){
 								vertex_id
@@ -401,7 +388,7 @@ impl GraphicsState{
 						}
 					}
 					//push model into dedup
-					deduplicated_models.push(IndexedGraphicsModelSingleTexture{
+					deduplicated_models.push(IndexedModelGraphicsSingleTexture{
 						unique_pos,
 						unique_tex,
 						unique_normal,
@@ -411,7 +398,7 @@ impl GraphicsState{
 						groups:vec![IndexedGroupFixedTexture{
 							polys
 						}],
-						instances:vec![GraphicsModelInstance{
+						instances:vec![ModelGraphicsInstance{
 							transform:glam::Mat4::IDENTITY,
 							normal_transform:glam::Mat3::IDENTITY,
 							color
@@ -429,9 +416,10 @@ impl GraphicsState{
 
 		//de-index models
 		let deduplicated_models_len=deduplicated_models.len();
-		let models:Vec<GraphicsModelSingleTexture>=deduplicated_models.into_iter().map(|model|{
+		let models:Vec<ModelGraphicsSingleTexture>=deduplicated_models.into_iter().map(|model|{
 			let mut vertices = Vec::new();
 			let mut index_from_vertex = std::collections::HashMap::new();//::<IndexedVertex,usize>
+			let mut entities = Vec::new();
 			//this mut be combined in a more complex way if the models use different render patterns per group
 				let mut indices = Vec::new();
 			for group in model.groups {
@@ -442,7 +430,7 @@ impl GraphicsState{
 							if let Some(&i)=index_from_vertex.get(&vertex_index){
 								indices.push(i);
 							}else{
-								let i=vertices.len();
+								let i=vertices.len() as u16;
 								let vertex=&model.unique_vertices[vertex_index as usize];
 								vertices.push(GraphicsVertex{
 									pos: model.unique_pos[vertex.pos as usize],
@@ -457,16 +445,11 @@ impl GraphicsState{
 					}
 				}
 			}
-			GraphicsModelSingleTexture{
+				entities.push(indices);
+			ModelGraphicsSingleTexture{
 				instances:model.instances,
-				entities:if (u32::MAX as usize)<vertices.len(){
-					panic!("Model has too many vertices!")
-				}else if (u16::MAX as usize)<vertices.len(){
-					crate::model_graphics::Entities::U32(vec![indices.into_iter().map(|vertex_id|vertex_id as u32).collect()])
-				}else{
-					crate::model_graphics::Entities::U16(vec![indices.into_iter().map(|vertex_id|vertex_id as u16).collect()])
-				},
 				vertices,
+				entities,
 				texture:model.texture,
 			}
 		}).collect();
@@ -519,17 +502,20 @@ impl GraphicsState{
 					usage: wgpu::BufferUsages::VERTEX,
 				});
 				//all of these are being moved here
-				self.models.push(GraphicsModel{
+				self.models.push(ModelGraphics{
 					instances:instances_chunk.to_vec(),
 					vertex_buf,
-					index_format:match &model.entities{
-						crate::model_graphics::Entities::U32(_)=>wgpu::IndexFormat::Uint32,
-						crate::model_graphics::Entities::U16(_)=>wgpu::IndexFormat::Uint16,
-					},
-					entities:match &model.entities{
-						crate::model_graphics::Entities::U32(entities)=>create_entities(device,entities),
-						crate::model_graphics::Entities::U16(entities)=>create_entities(device,entities),
-					},
+					entities: model.entities.iter().map(|indices|{
+						let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+							label: Some("Index"),
+							contents: bytemuck::cast_slice(&indices),
+							usage: wgpu::BufferUsages::INDEX,
+						});
+						Entity {
+							index_buf,
+							index_count: indices.len() as u32,
+						}
+					}).collect(),
 					bind_group: model_bind_group,
 					model_buf,
 				});
@@ -634,7 +620,6 @@ impl GraphicsState{
 			mag_filter: wgpu::FilterMode::Linear,
 			min_filter: wgpu::FilterMode::Linear,
 			mipmap_filter: wgpu::FilterMode::Linear,
-			anisotropy_clamp:16,
 			..Default::default()
 		});
 
@@ -702,7 +687,6 @@ impl GraphicsState{
 					label: Some("Skybox Texture"),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&skybox_image.data,
 			);
 
@@ -743,7 +727,6 @@ impl GraphicsState{
 					label: Some("Squid Texture"),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&image.data,
 			);
 
@@ -819,7 +802,6 @@ impl GraphicsState{
 			}),
 			primitive: wgpu::PrimitiveState {
 				front_face: wgpu::FrontFace::Cw,
-				cull_mode:Some(wgpu::Face::Front),
 				..Default::default()
 			},
 			depth_stencil: Some(wgpu::DepthStencilState {
@@ -834,7 +816,7 @@ impl GraphicsState{
 		});
 
 		let camera=GraphicsCamera::default();
-		let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,integer::Time::ZERO));
+		let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,crate::integer::Time::ZERO));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
 			contents: bytemuck::cast_slice(&camera_uniforms),
@@ -903,7 +885,7 @@ impl GraphicsState{
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
 		physics_output:crate::physics::PhysicsOutputState,
-		predicted_time:integer::Time,
+		predicted_time:crate::integer::Time,
 		mouse_pos:glam::IVec2,
 	) {
 		//TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
@@ -952,19 +934,17 @@ impl GraphicsState{
 							b: 0.3,
 							a: 1.0,
 						}),
-						store:wgpu::StoreOp::Store,
+						store: true,
 					},
 				})],
 				depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
 					view: &self.depth_view,
 					depth_ops: Some(wgpu::Operations {
 						load: wgpu::LoadOp::Clear(1.0),
-						store:wgpu::StoreOp::Discard,
+						store: false,
 					}),
 					stencil_ops: None,
 				}),
-				timestamp_writes:Default::default(),
-				occlusion_query_set:Default::default(),
 			});
 
 			rpass.set_bind_group(0, &self.bind_groups.camera, &[]);
@@ -976,7 +956,7 @@ impl GraphicsState{
 				rpass.set_vertex_buffer(0, model.vertex_buf.slice(..));
 
 				for entity in model.entities.iter() {
-					rpass.set_index_buffer(entity.index_buf.slice(..),model.index_format);
+					rpass.set_index_buffer(entity.index_buf.slice(..), wgpu::IndexFormat::Uint16);
 					rpass.draw_indexed(0..entity.index_count, 0, 0..model.instances.len() as u32);
 				}
 			}
@@ -992,7 +972,7 @@ impl GraphicsState{
 }
 const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
 const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
-fn get_instances_buffer_data(instances:&[GraphicsModelInstance]) -> Vec<f32> {
+fn get_instances_buffer_data(instances:&[ModelGraphicsInstance]) -> Vec<f32> {
 	let mut raw = Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
 	for (i,mi) in instances.iter().enumerate(){
     	let mut v = raw.split_off(MODEL_BUFFER_SIZE*i);

src/graphics_worker.rs

@@ -1,8 +1,6 @@
-use strafesnet_common::integer;
-
 pub enum Instruction{
-	Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2),
-	//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),
 	GenerateModels(crate::model::IndexedModelInstances),
 	ClearModels,
@@ -20,11 +18,10 @@ 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::new(move |ins:Instruction|{
 		match ins{
 			Instruction::GenerateModels(indexed_model_instances)=>{
@@ -34,20 +31,13 @@ pub fn new<'a>(
 				graphics.clear();
 			},
 			Instruction::Resize(size,user_settings)=>{
-				resize=Some((size,user_settings));
-			}
-			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
-				if let Some((size,user_settings))=&resize{
 				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());
+				graphics.resize(&device,&config,&user_settings);
 			}
-				//clear every time w/e
-				resize=None;
+			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
 				//this has to go deeper somehow
 				let frame=match surface.get_current_texture(){
 					Ok(frame)=>frame,

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_bsp.rs

@@ -1,232 +0,0 @@
-use strafesnet_common::integer;
-
-const VALVE_SCALE:f32=1.0/16.0;
-fn valve_transform(v:[f32;3])->integer::Planar64Vec3{
-	integer::Planar64Vec3::try_from([v[0]*VALVE_SCALE,v[2]*VALVE_SCALE,-v[1]*VALVE_SCALE]).unwrap()
-}
-pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Result<crate::model::IndexedModelInstances,vbsp::BspError>{
-	let mut s=Vec::new();
-
-	match input.read_to_end(&mut s){
-		Ok(_)=>(),
-		Err(e)=>println!("load_bsp::generate_indexed_models read_to_end failed: {:?}",e),
-	}
-
-	match vbsp::Bsp::read(s.as_slice()){
-		Ok(bsp)=>{
-			let mut spawn_point=integer::Planar64Vec3::ZERO;
-
-			let mut name_from_texture_id=Vec::new();
-			let mut texture_id_from_name=std::collections::HashMap::new();
-
-			let mut models=bsp.models().map(|world_model|{
-				//non-deduplicated
-				let mut spam_pos=Vec::new();
-				let mut spam_tex=Vec::new();
-				let mut spam_normal=Vec::new();
-				let mut spam_vertices=Vec::new();
-				let groups=world_model.faces()
-				.filter(|face| face.is_visible())//TODO: look at this
-				.map(|face|{
-					let face_texture=face.texture();
-					let face_texture_data=face_texture.texture_data();
-					let (texture_u,texture_v)=(glam::Vec3A::from_slice(&face_texture.texture_transforms_u[0..3]),glam::Vec3A::from_slice(&face_texture.texture_transforms_v[0..3]));
-					let texture_offset=glam::vec2(face_texture.texture_transforms_u[3],face_texture.texture_transforms_v[3]);
-					let texture_size=glam::vec2(face_texture_data.width as f32,face_texture_data.height as f32);
-
-					//texture
-					let texture_id=if let Some(&texture_id)=texture_id_from_name.get(face_texture_data.name()){
-						texture_id
-					}else{
-						let texture_id=name_from_texture_id.len() as u32;
-						texture_id_from_name.insert(face_texture_data.name().to_string(),texture_id);
-						name_from_texture_id.push(face_texture_data.name().to_string());
-						texture_id
-					};
-
-					//normal
-					let normal=face.normal();
-					let normal_idx=spam_normal.len() as u32;
-					spam_normal.push(valve_transform(<[f32;3]>::from(normal)));
-					let mut vertices:Vec<u32>=face.vertex_positions().map(|vertex_pos|{
-						let vertex_xyz=<[f32;3]>::from(vertex_pos);
-						let pos=glam::Vec3A::from_array(vertex_xyz);
-						let pos_idx=spam_pos.len();
-						spam_pos.push(valve_transform(vertex_xyz));
-
-						//calculate texture coordinates
-						let tex=(glam::vec2(pos.dot(texture_u),pos.dot(texture_v))+texture_offset)/texture_size;
-						let tex_idx=spam_tex.len() as u32;
-						spam_tex.push(tex);
-
-						let i=spam_vertices.len() as u32;
-						spam_vertices.push(crate::model::IndexedVertex{
-							pos: pos_idx as u32,
-							tex: tex_idx as u32,
-							normal: normal_idx,
-							color: 0,
-						});
-						i
-					}).collect();
-					vertices.reverse();
-					crate::model::IndexedGroup{
-						texture:Some(texture_id),
-						polys:vec![crate::model::IndexedPolygon{vertices}],
-					}
-				}).collect();
-				crate::model::IndexedModel{
-					unique_pos:spam_pos,
-					unique_tex:spam_tex,
-					unique_normal:spam_normal,
-					unique_color:vec![glam::Vec4::ONE],
-					unique_vertices:spam_vertices,
-					groups,
-					instances:vec![crate::model::ModelInstance{
-						attributes:crate::model::CollisionAttributes::Decoration,
-						transform:integer::Planar64Affine3::new(
-							integer::Planar64Mat3::default(),
-							valve_transform(<[f32;3]>::from(world_model.origin))
-						),
-						..Default::default()
-					}],
-				}
-			}).collect();
-
-			//dedupe prop models
-			let mut model_dedupe=std::collections::HashSet::new();
-			for prop in bsp.static_props(){
-				model_dedupe.insert(prop.model());
-			}
-
-			//generate unique meshes
-			let mut model_map=std::collections::HashMap::with_capacity(model_dedupe.len());
-			let mut prop_models=Vec::new();
-			for model_name in model_dedupe{
-				let model_name_lower=model_name.to_lowercase();
-				//.mdl, .vvd, .dx90.vtx
-				let mut path=std::path::PathBuf::from(model_name_lower.as_str());
-				let file_name=std::path::PathBuf::from(path.file_stem().unwrap());
-				path.pop();
-				path.push(file_name);
-				let mut vvd_path=path.clone();
-				let mut vtx_path=path.clone();
-				vvd_path.set_extension("vvd");
-				vtx_path.set_extension("dx90.vtx");
-				match (bsp.pack.get(model_name_lower.as_str()),bsp.pack.get(vvd_path.as_os_str().to_str().unwrap()),bsp.pack.get(vtx_path.as_os_str().to_str().unwrap())){
-					(Ok(Some(mdl_file)),Ok(Some(vvd_file)),Ok(Some(vtx_file)))=>{
-						match (vmdl::mdl::Mdl::read(mdl_file.as_ref()),vmdl::vvd::Vvd::read(vvd_file.as_ref()),vmdl::vtx::Vtx::read(vtx_file.as_ref())){
-							(Ok(mdl),Ok(vvd),Ok(vtx))=>{
-								let model=vmdl::Model::from_parts(mdl,vtx,vvd);
-								let texture_paths=model.texture_directories();
-								if texture_paths.len()!=1{
-									println!("WARNING: multiple texture paths");
-								}
-								let skin=model.skin_tables().nth(0).unwrap();
-
-								let mut spam_pos=Vec::with_capacity(model.vertices().len());
-								let mut spam_normal=Vec::with_capacity(model.vertices().len());
-								let mut spam_tex=Vec::with_capacity(model.vertices().len());
-								let mut spam_vertices=Vec::with_capacity(model.vertices().len());
-								for (i,vertex) in model.vertices().iter().enumerate(){
-									spam_pos.push(valve_transform(<[f32;3]>::from(vertex.position)));
-									spam_normal.push(valve_transform(<[f32;3]>::from(vertex.normal)));
-									spam_tex.push(glam::Vec2::from_array(vertex.texture_coordinates));
-									spam_vertices.push(crate::model::IndexedVertex{
-										pos:i as u32,
-										tex:i as u32,
-										normal:i as u32,
-										color:0,
-									});
-								}
-
-								let model_id=prop_models.len();
-								model_map.insert(model_name,model_id);
-								prop_models.push(crate::model::IndexedModel{
-									unique_pos:spam_pos,
-									unique_normal:spam_normal,
-									unique_tex:spam_tex,
-									unique_color:vec![glam::Vec4::ONE],
-									unique_vertices:spam_vertices,
-									groups:model.meshes().map(|mesh|{
-										let texture=if let (Some(texture_path),Some(texture_name))=(texture_paths.get(0),skin.texture(mesh.material_index())){
-											let mut path=std::path::PathBuf::from(texture_path.as_str());
-											path.push(texture_name);
-											let texture_location=path.as_os_str().to_str().unwrap();
-											let texture_id=if let Some(&texture_id)=texture_id_from_name.get(texture_location){
-												texture_id
-											}else{
-												println!("texture! {}",texture_location);
-												let texture_id=name_from_texture_id.len() as u32;
-												texture_id_from_name.insert(texture_location.to_string(),texture_id);
-												name_from_texture_id.push(texture_location.to_string());
-												texture_id
-											};
-											Some(texture_id)
-										}else{
-											None
-										};
-
-										crate::model::IndexedGroup{
-											texture,
-											polys:{
-												//looking at the code, it would seem that the strips are pre-deindexed into triangle lists when calling this function
-												mesh.vertex_strip_indices().map(|strip|{
-													strip.collect::<Vec<usize>>().chunks(3).map(|tri|{
-														crate::model::IndexedPolygon{vertices:vec![tri[0] as u32,tri[1] as u32,tri[2] as u32]}
-													}).collect::<Vec<crate::model::IndexedPolygon>>()
-												}).flatten().collect()
-											},
-										}
-									}).collect(),
-									instances:Vec::new(),
-								});
-							},
-							_=>println!("model_name={} error",model_name),
-						}
-					},
-					_=>println!("no model name={}",model_name),
-				}
-			}
-
-			//generate model instances
-			for prop in bsp.static_props(){
-				let placement=prop.as_prop_placement();
-				if let Some(&model_index)=model_map.get(placement.model){
-					prop_models[model_index].instances.push(crate::model::ModelInstance{
-						transform:integer::Planar64Affine3::new(
-							integer::Planar64Mat3::try_from(
-								glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
-								//TODO: figure this out
-								*glam::Mat3A::from_quat(glam::Quat::from_xyzw(
-									placement.rotation.v.x,//b
-									placement.rotation.v.y,//c
-									placement.rotation.v.z,//d
-									placement.rotation.s,//a
-								))
-							).unwrap(),
-							valve_transform(<[f32;3]>::from(placement.origin)),
-						),
-						attributes:crate::model::CollisionAttributes::Decoration,
-						..Default::default()
-					});
-				}else{
-					//println!("model not found {}",placement.model);
-				}
-			}
-
-			//actually add the prop models
-			prop_models.append(&mut models);
-
-			Ok(crate::model::IndexedModelInstances{
-				textures:name_from_texture_id,
-				models:prop_models,
-				spawn_point,
-				modes:Vec::new(),
-			})
-		},
-		Err(e)=>{
-			println!("rotten {:?}",e);
-			Err(e)
-		},
-	}
-}

src/load_roblox.rs

@@ -1,5 +1,5 @@
 use crate::primitives;
-use strafesnet_common::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
+use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
 
 fn class_is_a(class: &str, superclass: &str) -> bool {
 	if class==superclass {
@@ -14,17 +14,22 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
 	return false
 }
 fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
-	let mut stack=vec![instance];
-	while let Some(item)=stack.pop(){
-		for &referent in item.children(){
+	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
 			}
-				stack.push(c);
+			recursive_collect_superclass(objects,dom,c,superclass);
 		}
 	}
 }
+fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
+	let mut objects = std::vec::Vec::new();
+	recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
+	//get ids
+	//clear vec
+	//next class
+	objects
 }
 fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
 	Planar64Affine3::new(
@@ -48,19 +53,13 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
 		"Water"=>{
 			force_can_collide=false;
 			//TODO: read stupid CustomPhysicalProperties
-			intersecting.water=Some(crate::model::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
+			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});
 		},
-		// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
-		// 	mode_id:0,
-		// 	stage_id:0,
-		// 	force:false,
-		// 	behaviour:crate::model::StageElementBehaviour::Unordered
-		// })),
 		"SetVelocity"=>general.trajectory=Some(crate::model::GameMechanicSetTrajectory::Velocity(velocity)),
 		"MapFinish"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish})},
 		"MapAnticheat"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat})},
@@ -120,13 +119,6 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
 					_=>panic!("regex3[1] messed up bad"),
 				}
 			}
-			// else if let Some(captures)=lazy_regex::regex!(r"^(OrderedCheckpoint)(\d+)$")
-			// .captures(other){
-			// 	match &captures[1]{
-			// 		"OrderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Ordered{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()}),
-			// 		_=>panic!("regex3[1] messed up bad"),
-			// 	}
-			// }
 		}
 	}
 	//need some way to skip this
@@ -226,9 +218,9 @@ type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 #[derive(Clone,Eq,Hash,PartialEq)]
 enum RobloxBasePartDescription{
-	Sphere(RobloxPartDescription),
+	Sphere,
 	Part(RobloxPartDescription),
-	Cylinder(RobloxPartDescription),
+	Cylinder,
 	Wedge(RobloxWedgeDescription),
 	CornerWedge(RobloxCornerWedgeDescription),
 }
@@ -265,18 +257,6 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 			{
 				let model_transform=planar64_affine3_from_roblox(cf,size);
 
-				if model_transform.matrix3.determinant()==Planar64::ZERO{
-					let mut parent_ref=object.parent();
-					let mut full_path=object.name.clone();
-					while let Some(parent)=dom.get_by_ref(parent_ref){
-						full_path=format!("{}.{}",parent.name,full_path);
-						parent_ref=parent.parent();
-					}
-					println!("Zero determinant CFrame at location {}",full_path);
-					println!("matrix3:{}",model_transform.matrix3);
-					continue;
-				}
-
 				//push TempIndexedAttributes
 				let mut force_intersecting=false;
 				let mut temp_indexing_attributes=Vec::new();
@@ -285,12 +265,14 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 						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|WormholeOut)(\d+)$");
+						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,
 							}
@@ -319,7 +301,6 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							panic!("Part has no Shape!");
 						}
 					},
-					"TrussPart"=>primitives::Primitives::Cube,
 					"WedgePart"=>primitives::Primitives::Wedge,
 					"CornerWedgePart"=>primitives::Primitives::CornerWedge,
 					_=>{
@@ -414,9 +395,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 					f5,//Cube::Front
 				]=part_texture_description;
 				let basepart_texture_description=match shape{
-					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere,
 					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
-					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder([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
@@ -442,10 +423,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 					let model_id=indexed_models.len();
 					model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
 					indexed_models.push(match basepart_texture_description{
-						RobloxBasePartDescription::Sphere(part_texture_description)
-						|RobloxBasePartDescription::Cylinder(part_texture_description)
-						|RobloxBasePartDescription::Part(part_texture_description)=>{
-							let mut cube_face_description=primitives::CubeFaceDescription::default();
+						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{
@@ -464,8 +444,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							}
 							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::default();
+							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{
@@ -484,7 +465,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							primitives::generate_partial_unit_wedge(wedge_face_description)
 						},
 						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
-							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::default();
+							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{

src/main.rs

@@ -1,18 +1,18 @@
-use strafesnet_common::integer;
-
+mod bvh;
+mod aabb;
 mod model;
 mod setup;
 mod window;
 mod worker;
+mod zeroes;
+mod integer;
 mod physics;
 mod graphics;
 mod settings;
 mod primitives;
-mod load_bsp;
+mod instruction;
 mod load_roblox;
-mod face_crawler;
 mod compat_worker;
-mod model_physics;
 mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
@@ -44,7 +44,7 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
 						},
 					}
 				},
-				b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(),
+				//b"VBSP"=>Some(load_bsp::generate_indexed_models(input)),
 				//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
 				//b"SNFB"=>Some(sniffer::load_bot(input)),
 				other=>{
@@ -64,44 +64,49 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
 
 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());
-	//quad monkeys
 	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[0].instances.push(model::ModelInstance{
+	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[0].instances.push(model::ModelInstance{
+	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[0].instances.push(model::ModelInstance{
+	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[0].instances.push(model::ModelInstance{
+	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[1].instances.push(model::ModelInstance{
+	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[2].instances.push(model::ModelInstance{
+	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()
 	});
@@ -114,5 +119,6 @@ pub fn default_models()->model::IndexedModelInstances{
 }
 
 fn main(){
-	setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
+	let context=setup::setup(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str());
+	context.start();//creates and runs a window context
 }

src/model.rs

@@ -1,4 +1,4 @@
-use strafesnet_common::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
+use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
 pub type TextureCoordinate=glam::Vec2;
 pub type Color4=glam::Vec4;
 #[derive(Clone,Hash,PartialEq,Eq)]
@@ -50,10 +50,10 @@ pub struct IndexedModelInstances{
 }
 //stage description referencing flattened ids is spooky, but the map loading is meant to be deterministic.
 pub struct ModeDescription{
-	//TODO: put "default" style modifiers in mode
-	//pub style:StyleModifiers,
 	pub start:usize,//start=model_id
 	pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
+	pub 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>,
 }
@@ -61,6 +61,9 @@ 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)]
@@ -73,88 +76,84 @@ pub struct TempAttrSpawn{
 	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,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub struct ContactingLadder{
 	pub sticky:bool
 }
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub enum ContactingBehaviour{
     Surf,
-	Cling,//usable as a zipline, or other weird and wonderful things
     Ladder(ContactingLadder),
     Elastic(u32),//[1/2^32,1] 0=None (elasticity+1)/2^32
 }
 //you have this effect while intersecting
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub struct IntersectingWater{
 	pub viscosity:Planar64,
 	pub density:Planar64,
-	pub velocity:Planar64Vec3,
+	pub current:Planar64Vec3,
 }
 //All models can be given these attributes
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub struct GameMechanicAccelerator{
 	pub acceleration:Planar64Vec3
 }
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[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,Hash,Eq,PartialEq)]
+#[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,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub enum GameMechanicSetTrajectory{
-	//Speed-type SetTrajectory
 	AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
 	Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
-	DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
-	//Velocity-type SetTrajectory
 	TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
 		target_point:Planar64Vec3,
 		time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
 	},
-	TargetPointSpeed{//launch at a fixed speed and land at a target point
+	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
 }
-impl GameMechanicSetTrajectory{
-	fn is_velocity(&self)->bool{
-		match self{
-			GameMechanicSetTrajectory::AirTime(_)
-			|GameMechanicSetTrajectory::Height(_)
-			|GameMechanicSetTrajectory::DotVelocity{direction:_,dot:_}=>false,
-			GameMechanicSetTrajectory::TargetPointTime{target_point:_,time:_}
-			|GameMechanicSetTrajectory::TargetPointSpeed{target_point:_,speed:_,trajectory_choice:_}
-			|GameMechanicSetTrajectory::Velocity(_)=>true,
-		}
-	}
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub enum ZoneBehaviour{
 	//Start is indexed
 	//Checkpoints are indexed
 	Finish,
 	Anitcheat,
 }
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub struct GameMechanicZone{
 	pub mode_id:u32,
 	pub behaviour:ZoneBehaviour,
@@ -165,36 +164,24 @@ pub struct GameMechanicZone{
 // 	InRange(Planar64,Planar64),
 // 	OutsideRange(Planar64,Planar64),
 // }
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub enum StageElementBehaviour{
  	//Spawn,//The behaviour of stepping on a spawn setting the spawnid
-	SpawnAt,//must be standing on top to get effect. except cancollide false
+ 	SpawnAt,
  	Trigger,
  	Teleport,
  	Platform,
-	//Checkpoint acts like a trigger if you haven't hit all the checkpoints yet.
-	//Note that all stage elements act like this for the next stage.
-	Checkpoint,
-	//OrderedCheckpoint. You must pass through all of these in ascending order.
-	//If you hit them out of order it acts like a trigger.
-	//Do not support backtracking at all for now.
-	Ordered{
-		checkpoint_id:u32,
-	},
-	//UnorderedCheckpoint. You must pass through all of these in any order.
-	Unordered,
-	//If you get reset by a jump limit
  	JumpLimit(u32),
  	//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
 }
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[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,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub struct GameMechanicWormhole{
 	//destination does not need to be another wormhole
 	//this defines a one way portal to a destination model transform
@@ -202,13 +189,13 @@ pub struct GameMechanicWormhole{
 	pub destination_model_id:u32,
 	//(position,angles)*=origin.transform.inverse()*destination.transform
 }
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone)]
 pub enum TeleportBehaviour{
 	StageElement(GameMechanicStageElement),
 	Wormhole(GameMechanicWormhole),
 }
 //attributes listed in order of handling
-#[derive(Default,Clone,Hash,Eq,PartialEq)]
+#[derive(Default,Clone)]
 pub struct GameMechanicAttributes{
 	pub zone:Option<GameMechanicZone>,
 	pub booster:Option<GameMechanicBooster>,
@@ -218,28 +205,14 @@ pub struct GameMechanicAttributes{
 }
 impl GameMechanicAttributes{
 	pub fn any(&self)->bool{
-		self.zone.is_some()
-		||self.booster.is_some()
+		self.booster.is_some()
 		||self.trajectory.is_some()
+		||self.zone.is_some()
 		||self.teleport_behaviour.is_some()
 		||self.accelerator.is_some()
 	}
-	pub fn is_wrcp(&self,current_mode_id:u32)->bool{
-		self.trajectory.as_ref().map_or(false,|t|t.is_velocity())
-		&&match &self.teleport_behaviour{
-			Some(TeleportBehaviour::StageElement(
-				GameMechanicStageElement{
-					mode_id,
-					stage_id:_,
-					force:true,
-					behaviour:StageElementBehaviour::Trigger|StageElementBehaviour::Teleport
 }
-			))=>current_mode_id==*mode_id,
-			_=>false,
-		}
-	}
-}
-#[derive(Default,Clone,Hash,Eq,PartialEq)]
+#[derive(Default,Clone)]
 pub struct ContactingAttributes{
 	//friction?
 	pub contact_behaviour:Option<ContactingBehaviour>,
@@ -249,7 +222,7 @@ impl ContactingAttributes{
 		self.contact_behaviour.is_some()
 	}
 }
-#[derive(Default,Clone,Hash,Eq,PartialEq)]
+#[derive(Default,Clone)]
 pub struct IntersectingAttributes{
 	pub water:Option<IntersectingWater>,
 }

src/model_graphics.rs

@@ -11,7 +11,7 @@ pub struct GraphicsVertex {
 pub struct IndexedGroupFixedTexture{
 	pub polys:Vec<IndexedPolygon>,
 }
-pub struct IndexedGraphicsModelSingleTexture{
+pub struct IndexedModelGraphicsSingleTexture{
 	pub unique_pos:Vec<[f32; 3]>,
 	pub unique_tex:Vec<[f32; 2]>,
 	pub unique_normal:Vec<[f32; 3]>,
@@ -19,41 +19,37 @@ pub struct IndexedGraphicsModelSingleTexture{
 	pub unique_vertices:Vec<IndexedVertex>,
 	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
 	pub groups: Vec<IndexedGroupFixedTexture>,
-	pub instances:Vec<GraphicsModelInstance>,
+	pub instances:Vec<ModelGraphicsInstance>,
 }
-pub enum Entities{
-	U32(Vec<Vec<u32>>),
-	U16(Vec<Vec<u16>>),
-}
-pub struct GraphicsModelSingleTexture{
-	pub instances:Vec<GraphicsModelInstance>,
+pub struct ModelGraphicsSingleTexture{
+	pub instances: Vec<ModelGraphicsInstance>,
 	pub vertices: Vec<GraphicsVertex>,
-	pub entities:Entities,
+	pub entities: Vec<Vec<u16>>,
 	pub texture: Option<u32>,
 }
 #[derive(Clone,PartialEq)]
-pub struct GraphicsModelColor4(glam::Vec4);
-impl GraphicsModelColor4{
+pub struct ModelGraphicsColor4(glam::Vec4);
+impl ModelGraphicsColor4{
 	pub const fn get(&self)->glam::Vec4{
 		self.0
 	}
 }
-impl From<glam::Vec4> for GraphicsModelColor4{
+impl From<glam::Vec4> for ModelGraphicsColor4{
 	fn from(value:glam::Vec4)->Self{
 		Self(value)
 	}
 }
-impl std::hash::Hash for GraphicsModelColor4{
+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 GraphicsModelInstance{
+pub struct ModelGraphicsInstance{
 	pub transform:glam::Mat4,
 	pub normal_transform:glam::Mat3,
-	pub color:GraphicsModelColor4,
+	pub color:ModelGraphicsColor4,
 }

src/model_physics.rs

@@ -1,745 +1 @@
-use std::borrow::{Borrow,Cow};
-use strafesnet_common::zeroes;
-use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
-
-#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub struct VertId(usize);
-#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub struct EdgeId(usize);
-pub trait UndirectedEdge{
-	type DirectedEdge:Copy+DirectedEdge;
-	fn as_directed(&self,parity:bool)->Self::DirectedEdge;
-}
-impl UndirectedEdge for EdgeId{
-	type DirectedEdge=DirectedEdgeId;
-	fn as_directed(&self,parity:bool)->DirectedEdgeId{
-		DirectedEdgeId(self.0|((parity as usize)<<(usize::BITS-1)))
-	}
-}
-pub trait DirectedEdge{
-	type UndirectedEdge:Copy+UndirectedEdge;
-	fn as_undirected(&self)->Self::UndirectedEdge;
-	fn parity(&self)->bool;
-	//this is stupid but may work fine
-	fn reverse(&self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
-		self.as_undirected().as_directed(!self.parity())
-	}
-}
-/// DirectedEdgeId refers to an EdgeId when undirected.
-#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub struct DirectedEdgeId(usize);
-impl DirectedEdge for DirectedEdgeId{
-	type UndirectedEdge=EdgeId;
-	fn as_undirected(&self)->EdgeId{
-		EdgeId(self.0&!(1<<(usize::BITS-1)))
-	}
-	fn parity(&self)->bool{
-		self.0&(1<<(usize::BITS-1))!=0
-	}
-}
-#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub struct FaceId(usize);
-
-//Vertex <-> Edge <-> Face -> Collide
-pub enum FEV<F,E:DirectedEdge,V>{
-	Face(F),
-	Edge(E::UndirectedEdge),
-	Vert(V),
-}
-
-//use Unit32 #[repr(C)] for map files
-struct Face{
-	normal:Planar64Vec3,
-	dot:Planar64,
-}
-struct Vert(Planar64Vec3);
-pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
-	fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
-		let verts=self.edge_verts(edge_id);
-		self.vert(verts[1].clone())-self.vert(verts[0].clone())
-	}
-	fn directed_edge_n(&self,directed_edge_id:EDGE)->Planar64Vec3{
-		let verts=self.edge_verts(directed_edge_id.as_undirected());
-		(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
-	}
-	fn vert(&self,vert_id:VERT)->Planar64Vec3;
-	fn face_nd(&self,face_id:FACE)->(Planar64Vec3,Planar64);
-	fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
-	fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
-	fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
-	fn vert_edges(&self,vert_id:VERT)->Cow<Vec<EDGE>>;
-	fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
-}
-struct FaceRefs{
-	edges:Vec<DirectedEdgeId>,
-	//verts:Vec<VertId>,
-}
-struct EdgeRefs{
-	faces:[FaceId;2],//left, right
-	verts:[VertId;2],//bottom, top
-}
-struct VertRefs{
-	faces:Vec<FaceId>,
-	edges:Vec<DirectedEdgeId>,
-}
-pub struct PhysicsMesh{
-	faces:Vec<Face>,
-	verts:Vec<Vert>,
-	face_topology:Vec<FaceRefs>,
-	edge_topology:Vec<EdgeRefs>,
-	vert_topology:Vec<VertRefs>,
-}
-
-#[derive(Default,Clone)]
-struct VertRefGuy{
-	edges:std::collections::HashSet<DirectedEdgeId>,
-	faces:std::collections::HashSet<FaceId>,
-}
-#[derive(Clone,Hash,Eq,PartialEq)]
-struct EdgeRefVerts([VertId;2]);
-impl EdgeRefVerts{
-	fn new(v0:VertId,v1:VertId)->(Self,bool){
-		(if v0.0<v1.0{
-			Self([v0,v1])
-		}else{
-			Self([v1,v0])
-		},v0.0<v1.0)
-	}
-}
-struct EdgeRefFaces([FaceId;2]);
-impl EdgeRefFaces{
-	fn new()->Self{
-		Self([FaceId(0);2])
-	}
-	fn push(&mut self,i:usize,face_id:FaceId){
-		self.0[i]=face_id;
-	}
-}
-struct FaceRefEdges(Vec<DirectedEdgeId>);
-#[derive(Default)]
-struct EdgePool{
-	edge_guys:Vec<(EdgeRefVerts,EdgeRefFaces)>,
-	edge_id_from_guy:std::collections::HashMap<EdgeRefVerts,usize>,
-}
-impl EdgePool{
-	fn push(&mut self,edge_ref_verts:EdgeRefVerts)->(&mut EdgeRefFaces,EdgeId){
-		let edge_id=if let Some(&edge_id)=self.edge_id_from_guy.get(&edge_ref_verts){
-			edge_id
-		}else{
-			let edge_id=self.edge_guys.len();
-			self.edge_guys.push((edge_ref_verts.clone(),EdgeRefFaces::new()));
-			self.edge_id_from_guy.insert(edge_ref_verts,edge_id);
-			edge_id
-		};
-		(&mut unsafe{self.edge_guys.get_unchecked_mut(edge_id)}.1,EdgeId(edge_id))
-	}
-}
-impl From<&crate::model::IndexedModel> for PhysicsMesh{
-	fn from(indexed_model:&crate::model::IndexedModel)->Self{
-		assert!(indexed_model.unique_pos.len()!=0,"Mesh cannot have 0 vertices");
-		let verts=indexed_model.unique_pos.iter().map(|v|Vert(v.clone())).collect();
-		let mut vert_ref_guys=vec![VertRefGuy::default();indexed_model.unique_pos.len()];
-		let mut edge_pool=EdgePool::default();
-		let mut face_i=0;
-		let mut faces=Vec::new();
-		let mut face_ref_guys=Vec::new();
-		for group in indexed_model.groups.iter(){for poly in group.polys.iter(){
-			let face_id=FaceId(face_i);
-			//one face per poly
-			let mut normal=Planar64Vec3::ZERO;
-			let len=poly.vertices.len();
-			let face_edges=poly.vertices.iter().enumerate().map(|(i,&vert_id)|{
-				let vert0_id=indexed_model.unique_vertices[vert_id as usize].pos as usize;
-				let vert1_id=indexed_model.unique_vertices[poly.vertices[(i+1)%len] as usize].pos as usize;
-				//https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal (Newell's Method)
-				let v0=indexed_model.unique_pos[vert0_id];
-				let v1=indexed_model.unique_pos[vert1_id];
-				normal+=Planar64Vec3::new(
-					(v0.y()-v1.y())*(v0.z()+v1.z()),
-					(v0.z()-v1.z())*(v0.x()+v1.x()),
-					(v0.x()-v1.x())*(v0.y()+v1.y()),
-				);
-				//get/create edge and push face into it
-				let (edge_ref_verts,is_sorted)=EdgeRefVerts::new(VertId(vert0_id),VertId(vert1_id));
-				let (edge_ref_faces,edge_id)=edge_pool.push(edge_ref_verts);
-				//polygon vertices as assumed to be listed clockwise
-				//populate the edge face on the left or right depending on how the edge vertices got sorted
-				edge_ref_faces.push(!is_sorted as usize,face_id);
-				//index edges & face into vertices
-				{
-					let vert_ref_guy=unsafe{vert_ref_guys.get_unchecked_mut(vert0_id)};
-					vert_ref_guy.edges.insert(edge_id.as_directed(is_sorted));
-					vert_ref_guy.faces.insert(face_id);
-					unsafe{vert_ref_guys.get_unchecked_mut(vert1_id)}.edges.insert(edge_id.as_directed(!is_sorted));
-				}
-				//return directed_edge_id
-				edge_id.as_directed(is_sorted)
-			}).collect();
-			//choose precision loss randomly idk
-			normal=normal/len as i64;
-			let mut dot=Planar64::ZERO;
-			for &v in poly.vertices.iter(){
-				dot+=normal.dot(indexed_model.unique_pos[indexed_model.unique_vertices[v as usize].pos as usize]);
-			}
-			faces.push(Face{normal,dot:dot/len as i64});
-			face_ref_guys.push(FaceRefEdges(face_edges));
-			face_i+=1;
-		}}
-		//conceivably faces, edges, and vertices exist now
-		Self{
-			faces,
-			verts,
-			face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
-				FaceRefs{edges:face_ref_guy.0}
-			}).collect(),
-			edge_topology:edge_pool.edge_guys.into_iter().map(|(edge_ref_verts,edge_ref_faces)|
-				EdgeRefs{faces:edge_ref_faces.0,verts:edge_ref_verts.0}
-			).collect(),
-			vert_topology:vert_ref_guys.into_iter().map(|vert_ref_guy|
-				VertRefs{
-					edges:vert_ref_guy.edges.into_iter().collect(),
-					faces:vert_ref_guy.faces.into_iter().collect(),
-				}
-			).collect(),
-		}
-	}
-}
-
-impl PhysicsMesh{
-	pub fn verts<'a>(&'a self)->impl Iterator<Item=Planar64Vec3>+'a{
-		self.verts.iter().map(|Vert(pos)|*pos)
-	}
-}
-impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
-	fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
-		(self.faces[face_id.0].normal,self.faces[face_id.0].dot)
-	}
-	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
-	fn vert(&self,vert_id:VertId)->Planar64Vec3{
-		self.verts[vert_id.0].0
-	}
-	fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
-		Cow::Borrowed(&self.face_topology[face_id.0].edges)
-	}
-	fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
-		Cow::Borrowed(&self.edge_topology[edge_id.0].faces)
-	}
-	fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
-		Cow::Borrowed(&self.edge_topology[edge_id.0].verts)
-	}
-	fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
-		Cow::Borrowed(&self.vert_topology[vert_id.0].edges)
-	}
-	fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
-		Cow::Borrowed(&self.vert_topology[vert_id.0].faces)
-	}
-}
-
-pub struct TransformedMesh<'a>{
-	mesh:&'a PhysicsMesh,
-	transform:&'a integer::Planar64Affine3,
-	normal_transform:&'a integer::Planar64Mat3,
-	transform_det:Planar64,
-}
-impl TransformedMesh<'_>{
-	pub fn new<'a>(
-		mesh:&'a PhysicsMesh,
-		transform:&'a integer::Planar64Affine3,
-		normal_transform:&'a integer::Planar64Mat3,
-		transform_det:Planar64,
-		)->TransformedMesh<'a>{
-		TransformedMesh{
-			mesh,
-			transform,
-			normal_transform,
-			transform_det,
-		}
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->VertId{
-		let mut best_dot=Planar64::MIN;
-		let mut best_vert=VertId(0);
-		for (i,vert) in self.mesh.verts.iter().enumerate(){
-			let p=self.transform.transform_point3(vert.0);
-			let d=dir.dot(p);
-			if best_dot<d{
-				best_dot=d;
-				best_vert=VertId(i);
-			}
-		}
-		best_vert
-	}
-}
-impl MeshQuery<FaceId,DirectedEdgeId,VertId> for TransformedMesh<'_>{
-	fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
-		let (n,d)=self.mesh.face_nd(face_id);
-		let transformed_n=*self.normal_transform*n;
-		let transformed_d=d+transformed_n.dot(self.transform.translation)/self.transform_det;
-		(transformed_n/self.transform_det,transformed_d)
-	}
-	fn vert(&self,vert_id:VertId)->Planar64Vec3{
-		self.transform.transform_point3(self.mesh.vert(vert_id))
-	}
-	#[inline]
-	fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
-		self.mesh.face_edges(face_id)
-	}
-	#[inline]
-	fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
-		self.mesh.edge_faces(edge_id)
-	}
-	#[inline]
-	fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
-		self.mesh.edge_verts(edge_id)
-	}
-	#[inline]
-	fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
-		self.mesh.vert_edges(vert_id)
-	}
-	#[inline]
-	fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
-		self.mesh.vert_faces(vert_id)
-	}
-}
-
-//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
-//(face,vertex)
-//(edge,edge)
-//(vertex,face)
-#[derive(Clone,Copy)]
-pub enum MinkowskiVert{
-	VertVert(VertId,VertId),
-}
-#[derive(Clone,Copy)]
-pub enum MinkowskiEdge{
-	VertEdge(VertId,EdgeId),
-	EdgeVert(EdgeId,VertId),
-	//EdgeEdge when edges are parallel
-}
-impl UndirectedEdge for MinkowskiEdge{
-	type DirectedEdge=MinkowskiDirectedEdge;
-	fn as_directed(&self,parity:bool)->Self::DirectedEdge{
-		match self{
-			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(*v0,e1.as_directed(parity)),
-			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),*v1),
-		}
-	}
-}
-#[derive(Clone,Copy)]
-pub enum MinkowskiDirectedEdge{
-	VertEdge(VertId,DirectedEdgeId),
-	EdgeVert(DirectedEdgeId,VertId),
-	//EdgeEdge when edges are parallel
-}
-impl DirectedEdge for MinkowskiDirectedEdge{
-	type UndirectedEdge=MinkowskiEdge;
-	fn as_undirected(&self)->Self::UndirectedEdge{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
-			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
-		}
-	}
-	fn parity(&self)->bool{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)
-			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
-		}
-	}
-}
-#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub enum MinkowskiFace{
-	VertFace(VertId,FaceId),
-	EdgeEdge(EdgeId,EdgeId,bool),
-	FaceVert(FaceId,VertId),
-	//EdgeFace
-	//FaceEdge
-	//FaceFace
-}
-
-pub struct MinkowskiMesh<'a>{
-	mesh0:&'a TransformedMesh<'a>,
-	mesh1:&'a TransformedMesh<'a>,
-}
-
-//infinity fev algorithm state transition
-enum Transition{
-	Done,//found closest vert, no edges are better
-	Vert(MinkowskiVert),//transition to vert
-}
-enum EV{
-	Vert(MinkowskiVert),
-	Edge(MinkowskiEdge),
-}
-
-impl MinkowskiMesh<'_>{
-	pub fn minkowski_sum<'a>(mesh0:&'a TransformedMesh,mesh1:&'a TransformedMesh)->MinkowskiMesh<'a>{
-		MinkowskiMesh{
-			mesh0,
-			mesh1,
-		}
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
-	}
-	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
-		let mut best_transition=Transition::Done;
-		for &directed_edge_id in self.vert_edges(vert_id).iter(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//is boundary uncrossable by a crawl from infinity
-			let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
-			//select opposite vertex
-			let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
-			//test if it's closer
-			let diff=point-self.vert(test_vert_id);
-			if zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
-				let distance_squared=diff.dot(diff);
-				if distance_squared<*best_distance_squared{
-					best_transition=Transition::Vert(test_vert_id);
-					*best_distance_squared=distance_squared;
-				}
-			}
-		}
-		best_transition
-	}
-	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
-		let mut best_transition=EV::Vert(vert_id);
-		let diff=point-self.vert(vert_id);
-		for &directed_edge_id in self.vert_edges(vert_id).iter(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//is boundary uncrossable by a crawl from infinity
-			//check if time of collision is outside Time::MIN..Time::MAX
-			let d=edge_n.dot(diff);
-			if zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
-				//test the edge
-				let edge_nn=edge_n.dot(edge_n);
-				if Planar64::ZERO<=d&&d<=edge_nn{
-					let distance_squared={
-						let c=diff.cross(edge_n);
-						c.dot(c)/edge_nn
-					};
-					if distance_squared<=*best_distance_squared{
-						best_transition=EV::Edge(directed_edge_id.as_undirected());
-						*best_distance_squared=distance_squared;
-					}
-				}
-			}
-		}
-		best_transition
-	}
-	fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
-		let mut best_distance_squared={
-			let diff=point-self.vert(vert_id);
-			diff.dot(diff)
-		};
-		loop{
-			match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
-				Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
-				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
-			}
-		}
-	}
-	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>{
-		//start on any vertex
-		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
-		//cross edge-face boundary if it's uncrossable
-		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
-			//if a vert is returned, it is the closest point to the infinity point
-			EV::Vert(vert_id)=>FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Vert(vert_id),
-			EV::Edge(edge_id)=>{
-				//cross to face if the boundary is not crossable and we are on the wrong side
-				let edge_n=self.edge_n(edge_id);
-				// point is multiplied by two because vert_sum sums two vertices.
-				let delta_pos=point*2-{
-					let &[v0,v1]=self.edge_verts(edge_id).borrow();
-					self.vert(v0)+self.vert(v1)
-				};
-				for (i,&face_id) in self.edge_faces(edge_id).iter().enumerate(){
-					let face_n=self.face_nd(face_id).0;
-					//edge-face boundary nd, n facing out of the face towards the edge
-					let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
-					let boundary_d=boundary_n.dot(delta_pos);
-					//check if time of collision is outside Time::MIN..Time::MAX
-					//infinity_dir can always be treated as a velocity
-					if (boundary_d)<=Planar64::ZERO&&zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
-						//both faces cannot pass this condition, return early if one does.
-						return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
-					}
-				}
-				FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Edge(edge_id)
-			},
-		}
-	}
-	fn closest_fev_not_inside(&self,mut infinity_body:crate::physics::Body)->Option<FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>>{
-		infinity_body.infinity_dir().map_or(None,|dir|{
-			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
-			//a line is simpler to solve than a parabola
-			infinity_body.velocity=dir;
-			infinity_body.acceleration=Planar64Vec3::ZERO;
-			//crawl in from negative infinity along a tangent line to get the closest fev
-			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN,infinity_body.time){
-				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
-				crate::face_crawler::CrawlResult::Hit(_,_)=>None,
-			}
-		})
-	}
-	pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
-		self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
-			//continue forwards along the body parabola
-			match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
-				crate::face_crawler::CrawlResult::Miss(_)=>None,
-				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
-			}
-		})
-	}
-	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
-		//create an extrapolated body at time_limit
-		let infinity_body=crate::physics::Body::new(
-			relative_body.extrapolated_position(time_limit),
-			-relative_body.extrapolated_velocity(time_limit),
-			relative_body.acceleration,
-			-time_limit,
-		);
-		self.closest_fev_not_inside(infinity_body).map_or(None,|fev|{
-			//continue backwards along the body parabola
-			match crate::face_crawler::crawl_fev(fev,self,&-relative_body.clone(),-time_limit,-relative_body.time){
-				crate::face_crawler::CrawlResult::Miss(_)=>None,
-				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,-time)),//no need to test -time<time_limit because of the first step
-			}
-		})
-	}
-	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,integer::Time)>{
-		//no algorithm needed, there is only one state and two cases (Edge,None)
-		//determine when it passes an edge ("sliding off" case)
-		let mut best_time=time_limit;
-		let mut best_edge=None;
-		let face_n=self.face_nd(contact_face_id).0;
-		for &directed_edge_id in self.face_edges(contact_face_id).iter(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//f x e points in
-			let n=face_n.cross(edge_n);
-			let verts=self.edge_verts(directed_edge_id.as_undirected());
-			let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
-			//WARNING! d outside of *2
-			for t in zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
-				let t=relative_body.time+integer::Time::from(t);
-				if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
-					best_time=t;
-					best_edge=Some(directed_edge_id);
-					break;
-				}
-			}
-		}
-		best_edge.map(|e|(e.as_undirected(),best_time))
-	}
-}
-impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
-	fn face_nd(&self,face_id:MinkowskiFace)->(Planar64Vec3,Planar64){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				let (n,d)=self.mesh1.face_nd(f1);
-				(-n,d-n.dot(self.mesh0.vert(v0)))
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let edge0_n=self.mesh0.edge_n(e0);
-				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).borrow();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).borrow();
-				let n=edge0_n.cross(edge1_n);
-				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
-				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				(n*(parity as i64*4-2),(e0d-e1d)*(parity as i64*2-1))
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				let (n,d)=self.mesh0.face_nd(f0);
-				(n,d-n.dot(self.mesh1.vert(v1)))
-			},
-		}
-	}
-	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				self.mesh0.vert(v0)-self.mesh1.vert(v1)
-			},
-		}
-	}
-	fn face_edges(&self,face_id:MinkowskiFace)->Cow<Vec<MinkowskiDirectedEdge>>{
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				Cow::Owned(self.mesh1.face_edges(f1).iter().map(|&edge_id1|{
-					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
-				}).collect())
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let e0v=self.mesh0.edge_verts(e0);
-				let e1v=self.mesh1.edge_verts(e1);
-				//could sort this if ordered edges are needed
-				//probably just need to reverse this list according to parity
-				Cow::Owned(vec![
-					MinkowskiDirectedEdge::VertEdge(e0v[0],e1.as_directed(parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v[0]),
-					MinkowskiDirectedEdge::VertEdge(e0v[1],e1.as_directed(!parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v[1]),
-				])
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				Cow::Owned(self.mesh0.face_edges(f0).iter().map(|&edge_id0|{
-					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
-				}).collect())
-			},
-		}
-	}
-	fn edge_faces(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiFace;2]>{
-		match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>{
-				//faces are listed backwards from the minkowski mesh
-				let v0e=self.mesh0.vert_edges(v0);
-				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).borrow();
-				Cow::Owned([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d=Planar64::ZERO;
-					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
-					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
-					for &directed_edge_id0 in v0e.iter(){
-						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
-						//must be behind other face.
-						let d=edge_face1_n.dot(edge0_n);
-						if d<Planar64::ZERO{
-							let edge0_nn=edge0_n.dot(edge0_n);
-							//divide by zero???
-							let dd=d*d/(edge_face1_nn*edge0_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id0);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::VertFace(v0,edge_face_id1),
-						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
-					)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				//tracking index with an external variable because .enumerate() is not available
-				let v1e=self.mesh1.vert_edges(v1);
-				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).borrow();
-				Cow::Owned([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d=Planar64::ZERO;
-					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
-					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
-					for &directed_edge_id1 in v1e.iter(){
-						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
-						let d=edge_face0_n.dot(edge1_n);
-						if d<Planar64::ZERO{
-							let edge1_nn=edge1_n.dot(edge1_n);
-							let dd=d*d/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id1);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::FaceVert(edge_face_id0,v1),
-						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
-					)
-				}))
-			},
-		}
-	}
-	fn edge_verts(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiVert;2]>{
-		match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>{
-				Cow::Owned(self.mesh1.edge_verts(e1).map(|vert_id1|{
-					MinkowskiVert::VertVert(v0,vert_id1)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				Cow::Owned(self.mesh0.edge_verts(e0).map(|vert_id0|{
-					MinkowskiVert::VertVert(vert_id0,v1)
-				}))
-			},
-		}
-	}
-	fn vert_edges(&self,vert_id:MinkowskiVert)->Cow<Vec<MinkowskiDirectedEdge>>{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				let mut edges=Vec::new();
-				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f=self.mesh0.vert_faces(v0);
-				let v1f=self.mesh1.vert_faces(v1);
-				let v0f_n:Vec<Planar64Vec3>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<Planar64Vec3>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				let the_len=v0f.len()+v1f.len();
-				for &directed_edge_id in self.mesh0.vert_edges(v0).iter(){
-					let n=self.mesh0.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					//make a set of faces
-					let mut face_normals=Vec::with_capacity(the_len);
-					//add mesh0 faces as-is
-					face_normals.clone_from(&v0f_n);
-					for face_n in &v1f_n{
-						//add reflected mesh1 faces
-						face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
-					}
-					if is_empty_volume(face_normals){
-						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
-					}
-				}
-				for &directed_edge_id in self.mesh1.vert_edges(v1).iter(){
-					let n=self.mesh1.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					let mut face_normals=Vec::with_capacity(the_len);
-					face_normals.clone_from(&v1f_n);
-					for face_n in &v0f_n{
-						face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
-					}
-					if is_empty_volume(face_normals){
-						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
-					}
-				}
-				Cow::Owned(edges)
-			},
-		}
-	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<Vec<MinkowskiFace>>{
-		unimplemented!()
-	}
-}
-
-fn is_empty_volume(normals:Vec<Planar64Vec3>)->bool{
-	let len=normals.len();
-	for i in 0..len-1{
-		for j in i+1..len{
-			let n=normals[i].cross(normals[j]);
-			let mut d_comp=None;
-			for k in 0..len{
-				if k!=i&&k!=j{
-					let d=n.dot(normals[k]);
-					if let Some(comp)=&d_comp{
-						if *comp*d<Planar64::ZERO{
-							return true;
-						}
-					}else{
-						d_comp=Some(d);
-					}
-				}
-			}
-		}
-	}
-	return false;
-}
-
-#[test]
-fn test_is_empty_volume(){
-	assert!(!is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z].to_vec()));
-	assert!(is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z,Planar64Vec3::NEG_X].to_vec()));
-}
-
-#[test]
-fn build_me_a_cube(){
-	let unit_cube=crate::primitives::unit_cube();
-	let mesh=PhysicsMesh::from(&unit_cube);
-	//println!("mesh={:?}",mesh);
-}
+//

src/physics_worker.rs

@@ -1,8 +1,6 @@
+use crate::integer::Time;
 use crate::physics::{MouseState,PhysicsInputInstruction};
-use strafesnet_common::integer::Time;
-use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
-use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
-
+use crate::instruction::{TimedInstruction,InstructionConsumer};
 #[derive(Debug)]
 pub enum InputInstruction {
 	MoveMouse(glam::IVec2),
@@ -25,35 +23,10 @@ pub enum Instruction{
 	//Graphics(crate::graphics_worker::Instruction),
 }
 
-pub struct Speed{
-	pub player_vel:Planar64Vec3,
-	pub time:Time
-}
-
-impl std::ops::Neg for Speed{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		Self{
-			player_vel:self.player_vel,
-			time:self.time
-		}
-	}
-}
-
-impl  Speed{
-	pub fn new(player_vel:Planar64Vec3,time:Time)->Self{
-		Self{
-			player_vel,
-			time,
-		}
-	}
-}
 	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();
-		let mut next_velocity_print=std::time::Instant::now();
-		let mut player_vel = physics.body.velocity.length();
 		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{
@@ -137,11 +110,6 @@ impl  Speed{
 						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
 					});
 				}
-				//some random print stuff
-				if 3.0/5.0<next_velocity_print.elapsed().as_secs_f64(){
-					next_velocity_print=next_velocity_print+std::time::Duration::from_secs_f64(1.0/30.0);
-					println!("velocity: {} u/s", (Planar64Vec3::new(physics.body.velocity.x(), Planar64::int(0), physics.body.velocity.z())).length()*(Planar64::int(130)/9));
-				}
 			}
 			match ins.instruction{
 				Instruction::Render=>{

src/primitives.rs

@@ -1,5 +1,5 @@
 use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
-use strafesnet_common::integer::Planar64Vec3;
+use crate::integer::Planar64Vec3;
 
 #[derive(Debug)]
 pub enum Primitives{
@@ -126,21 +126,17 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	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{
-	unit_cube()
-}
-#[derive(Default)]
-pub struct CubeFaceDescription([Option<FaceDescription>;6]);
-impl CubeFaceDescription{
-	pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
-		self.0[index as usize]=Some(value);
-	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,6>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	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::default();
+	let mut t=CubeFaceDescription::new();
 	t.insert(CubeFace::Right,FaceDescription::default());
 	t.insert(CubeFace::Top,FaceDescription::default());
 	t.insert(CubeFace::Back,FaceDescription::default());
@@ -149,21 +145,17 @@ pub fn unit_cube()->crate::model::IndexedModel{
 	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{
-	unit_cube()
-}
-#[derive(Default)]
-pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
-impl WedgeFaceDescription{
-	pub fn insert(&mut self,index:WedgeFace,value:FaceDescription){
-		self.0[index as usize]=Some(value);
-	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	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::default();
+	let mut t=WedgeFaceDescription::new();
 	t.insert(WedgeFace::Right,FaceDescription::default());
 	t.insert(WedgeFace::TopFront,FaceDescription::default());
 	t.insert(WedgeFace::Back,FaceDescription::default());
@@ -171,18 +163,9 @@ pub fn unit_wedge()->crate::model::IndexedModel{
 	t.insert(WedgeFace::Bottom,FaceDescription::default());
 	generate_partial_unit_wedge(t)
 }
-#[derive(Default)]
-pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
-impl CornerWedgeFaceDescription{
-	pub fn insert(&mut self,index:CornerWedgeFace,value:FaceDescription){
-		self.0[index as usize]=Some(value);
-	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
-	}
-}
+pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,FaceDescription>;
 pub fn unit_cornerwedge()->crate::model::IndexedModel{
-	let mut t=CornerWedgeFaceDescription::default();
+	let mut t=CornerWedgeFaceDescription::new();
 	t.insert(CornerWedgeFace::Right,FaceDescription::default());
 	t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
@@ -206,6 +189,18 @@ impl std::default::Default for FaceDescription{
 		}
 	}
 }
+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{
@@ -217,7 +212,7 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.pairs(){
+	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
@@ -238,6 +233,14 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
 			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]);
@@ -324,7 +327,7 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.pairs(){
+	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
@@ -345,6 +348,13 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
 			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]);
@@ -429,7 +439,7 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.pairs(){
+	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
@@ -450,6 +460,13 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 			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]);

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
@@ -42,30 +41,28 @@ 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
-		//let optional_features=optional_features();
+		let optional_features=optional_features();
 		let required_features=required_features();
 
 		//no helper function smh gotta write it myself
@@ -123,13 +120,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,8 +138,8 @@ impl<'a> SetupContextPartial3<'a>{
 			.request_device(
 				&wgpu::DeviceDescriptor {
 					label: None,
-					required_features: (optional_features & self.adapter.features()) | required_features,
-					required_limits: needed_limits,
+					features: (optional_features & self.adapter.features()) | required_features,
+					limits: needed_limits,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
@@ -157,21 +154,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{
@@ -183,36 +179,58 @@ 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);
+		let window=crate::window::WindowContextSetup::new(&setup_context,window);
 		//the thread that spawns the physics thread
 		let window_thread=window.into_worker(setup_context);
 
@@ -220,6 +238,7 @@ pub fn setup_and_start(title:String){
 		let root_time=std::time::Instant::now();
 		run_event_loop(event_loop,window_thread,root_time).unwrap();
 	}
+}
 
 fn run_event_loop(
 	event_loop:winit::event_loop::EventLoop<()>,
@@ -227,7 +246,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/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>),
@@ -16,7 +15,7 @@ struct WindowContext<'a>{
 	mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
 	screen_size:glam::UVec2,
 	user_settings:crate::settings::UserSettings,
-	window:&'a winit::window::Window,
+	window:winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
 }
 
@@ -24,7 +23,7 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0, self.screen_size.y as f32/2.0)
 	}
-	fn window_event(&mut self,time: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)=>{
 				//blocking because it's simpler...
@@ -33,7 +32,7 @@ impl WindowContext<'_>{
 					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
 				//recalculate pressed keys on focus
 			},
@@ -122,7 +121,7 @@ impl WindowContext<'_>{
 		}
 	}
 
-	fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
+	fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
 		match event {
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
@@ -159,15 +158,15 @@ impl WindowContext<'_>{
 	}
 }
 
-pub struct WindowContextSetup<'a>{
+pub struct WindowContextSetup{
 	user_settings:crate::settings::UserSettings,
-	window:&'a winit::window::Window,
+	window:winit::window::Window,
 	physics:crate::physics::PhysicsState,
 	graphics:crate::graphics::GraphicsState,
 }
 
-impl<'a> WindowContextSetup<'a>{
-	pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
+impl WindowContextSetup{
+	pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
 		//wee
 		let user_settings=crate::settings::read_user_settings();
 
@@ -195,7 +194,7 @@ impl<'a> WindowContextSetup<'a>{
 		}
 	}
 
-	fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{
+	fn into_context<'a>(self,setup_context:crate::setup::SetupContext)->WindowContext<'a>{
 		let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
 		let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
 		WindowContext{
@@ -209,7 +208,7 @@ impl<'a> WindowContextSetup<'a>{
 		}
 	}
 
-	pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
+	pub fn into_worker<'a>(self,setup_context:crate::setup::SetupContext)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
 		let mut window_context=self.into_context(setup_context);
 		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
 			match ins.instruction{

src/worker.rs

@@ -1,6 +1,6 @@
 use std::thread;
 use std::sync::{mpsc,Arc};
-use parking_lot::Mutex;
+use parking_lot::{Mutex,Condvar};
 
 //WorkerPool
 struct Pool(u32);
@@ -175,16 +175,16 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 
 #[test]//How to run this test with printing: cargo test --release -- --nocapture
 fn test_worker() {
+	println!("hiiiii");
 	// Create the worker thread
-	let test_body=crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO);
-	let worker=QRWorker::new(crate::physics::Body::default(),
-		|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
+	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 = strafesnet_common::instruction::TimedInstruction{
-			time:strafesnet_common::integer::Time::ZERO,
+		let task = crate::instruction::TimedInstruction{
+			time:crate::integer::Time::ZERO,
 			instruction:crate::physics::PhysicsInstruction::StrafeTick,
 		};
 		worker.send(task).unwrap();
@@ -194,17 +194,17 @@ fn test_worker() {
 	// 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 = strafesnet_common::instruction::TimedInstruction{
-		time:strafesnet_common::integer::Time::ZERO,
+	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,32 @@
+//find roots of polynomials
+use crate::integer::Planar64;
+
+#[inline]
+pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
+	if a2==Planar64::ZERO{
+		return zeroes1(a0, a1);
+	}
+	let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
+	if 0<radicand {
+		//start with f64 sqrt
+		let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
+		//TODO: one or two newtons
+		if Planar64::ZERO<a2 {
+			return vec![(-a1-planar_radicand)/(a2*2),(-a1+planar_radicand)/(a2*2)];
+		} else {
+			return vec![(-a1+planar_radicand)/(a2*2),(-a1-planar_radicand)/(a2*2)];
+		}
+	} else if radicand==0 {
+		return vec![a1/(a2*-2)];
+	} else {
+		return vec![];
+	}
+}
+#[inline]
+pub fn zeroes1(a0:Planar64,a1:Planar64) -> Vec<Planar64> {
+	if a1==Planar64::ZERO{
+		return vec![];
+	} else {
+		return vec![-a0/a1];
+	}
+}

tools/arcane

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

tools/bhop_maps

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

tools/cross-compile.sh

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

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

tools/textures

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

tools/toc

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

tools/utopia

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