Update smallvec, built and ran tested

WAYLAND_DISPLAY= mangohud cargo run

.cargo/config.toml

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

.gitignore

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

Cargo.toml

@@ -1,36 +1,29 @@
 [package]
 name = "strafe-client"
-version = "0.10.5"
+version = "0.9.0"
 edition = "2021"
-repository = "https://git.itzana.me/StrafesNET/strafe-client"
-license = "Custom"
-description = "StrafesNET game client for bhop and surf."
-authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[features]
-default = ["snf"]
-snf = ["dep:strafesnet_snf"]
-source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
-roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
 bytemuck = { version = "1.13.1", features = ["derive"] }
 configparser = "3.0.2"
 ddsfile = "0.5.1"
-glam = "0.29.0"
+glam = "0.24.1"
-id = { version = "0.1.0", registry = "strafesnet" }
+lazy-regex = "3.0.2"
+obj = "0.10.2"
 parking_lot = "0.12.1"
 pollster = "0.3.0"
-strafesnet_bsp_loader = { version = "0.2.1", registry = "strafesnet", optional = true }
+rbx_binary = "0.7.1"
-strafesnet_common = { version = "0.5.2", registry = "strafesnet" }
+rbx_dom_weak = "2.5.0"
-strafesnet_deferred_loader = { version = "0.4.0", features = ["legacy"], registry = "strafesnet", optional = true }
+rbx_reflection_database = "0.2.7"
-strafesnet_rbx_loader = { version = "0.5.1", registry = "strafesnet", optional = true }
+rbx_xml = "0.13.1"
-strafesnet_snf = { version = "0.2.0", registry = "strafesnet", optional = true }
+vbsp = "0.5.0"
-wgpu = "22.1.0"
+vmdl = "0.1.1"
-winit = "0.30.5"
+wgpu = "0.19.0"
+winit = { version = "0.29.2" }
 
-[profile.release]
+#[profile.release]
 #lto = true
-strip = true
+#strip = true
-codegen-units = 1
+#codegen-units = 1

LICENSE

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

src/aabb.rs

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

src/bvh.rs

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

src/face_crawler.rs

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

src/file.rs

@@ -1,144 +0,0 @@
-use std::io::Read;
-
-#[derive(Debug)]
-pub enum ReadError{
-	#[cfg(feature="roblox")]
-	Roblox(strafesnet_rbx_loader::ReadError),
-	#[cfg(feature="source")]
-	Source(strafesnet_bsp_loader::ReadError),
-	#[cfg(feature="snf")]
-	StrafesNET(strafesnet_snf::Error),
-	#[cfg(feature="snf")]
-	StrafesNETMap(strafesnet_snf::map::Error),
-	Io(std::io::Error),
-	UnknownFileFormat,
-}
-impl std::fmt::Display for ReadError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ReadError{}
-
-pub enum DataStructure{
-	#[cfg(feature="roblox")]
-	Roblox(strafesnet_rbx_loader::Model),
-	#[cfg(feature="source")]
-	Source(strafesnet_bsp_loader::Bsp),
-	#[cfg(feature="snf")]
-	StrafesNET(strafesnet_common::map::CompleteMap),
-}
-
-pub fn read<R:Read+std::io::Seek>(input:R)->Result<DataStructure,ReadError>{
-	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
-	match &peek[0..4]{
-		#[cfg(feature="roblox")]
-		b"<rob"=>Ok(DataStructure::Roblox(strafesnet_rbx_loader::read(buf).map_err(ReadError::Roblox)?)),
-		#[cfg(feature="source")]
-		b"VBSP"=>Ok(DataStructure::Source(strafesnet_bsp_loader::read(buf).map_err(ReadError::Source)?)),
-		#[cfg(feature="snf")]
-		b"SNFM"=>Ok(DataStructure::StrafesNET(
-			strafesnet_snf::read_map(buf).map_err(ReadError::StrafesNET)?
-			.into_complete_map().map_err(ReadError::StrafesNETMap)?
-		)),
-		_=>Err(ReadError::UnknownFileFormat),
-	}
-}
-
-#[derive(Debug)]
-pub enum LoadError{
-	ReadError(ReadError),
-	File(std::io::Error),
-	Io(std::io::Error),
-}
-impl std::fmt::Display for LoadError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for LoadError{}
-
-pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<strafesnet_common::map::CompleteMap,LoadError>{
-	//blocking because it's simpler...
-	let file=std::fs::File::open(path).map_err(LoadError::File)?;
-	match read(file).map_err(LoadError::ReadError)?{
-		#[cfg(feature="snf")]
-		DataStructure::StrafesNET(map)=>Ok(map),
-		#[cfg(feature="roblox")]
-		DataStructure::Roblox(model)=>{
-			let mut place=model.into_place();
-			place.run_scripts();
-
-			let mut loader=strafesnet_deferred_loader::roblox_legacy();
-
-			let (texture_loader,mesh_loader)=loader.get_inner_mut();
-
-			let map_step1=strafesnet_rbx_loader::convert(
-				&place,
-				|name|texture_loader.acquire_render_config_id(name),
-				|name|mesh_loader.acquire_mesh_id(name),
-			);
-
-			let meshpart_meshes=mesh_loader.load_meshes().map_err(LoadError::Io)?;
-
-			let map_step2=map_step1.add_meshpart_meshes_and_calculate_attributes(
-				meshpart_meshes.into_iter().map(|(mesh_id,loader_model)|
-					(mesh_id,strafesnet_rbx_loader::data::RobloxMeshBytes::new(loader_model.get()))
-				)
-			);
-
-			let (textures,render_configs)=loader.into_render_configs().map_err(LoadError::Io)?.consume();
-
-			let map=map_step2.add_render_configs_and_textures(
-				render_configs.into_iter(),
-				textures.into_iter().map(|(texture_id,texture)|
-					(texture_id,match texture{
-						strafesnet_deferred_loader::texture::Texture::ImageDDS(data)=>data,
-					})
-				)
-			);
-
-			Ok(map)
-		},
-		#[cfg(feature="source")]
-		DataStructure::Source(bsp)=>{
-			let mut loader=strafesnet_deferred_loader::source_legacy();
-
-			let (texture_loader,mesh_loader)=loader.get_inner_mut();
-
-			let map_step1=strafesnet_bsp_loader::convert(
-				&bsp,
-				|name|texture_loader.acquire_render_config_id(name),
-				|name|mesh_loader.acquire_mesh_id(name),
-			);
-
-			let prop_meshes=mesh_loader.load_meshes(bsp.as_ref());
-
-			let map_step2=map_step1.add_prop_meshes(
-				//the type conflagulator 9000
-				prop_meshes.into_iter().map(|(mesh_id,loader_model)|
-					(mesh_id,strafesnet_bsp_loader::data::ModelData{
-						mdl:strafesnet_bsp_loader::data::MdlData::new(loader_model.mdl.get()),
-						vtx:strafesnet_bsp_loader::data::VtxData::new(loader_model.vtx.get()),
-						vvd:strafesnet_bsp_loader::data::VvdData::new(loader_model.vvd.get()),
-					})
-				),
-				|name|texture_loader.acquire_render_config_id(name),
-			);
-
-			let (textures,render_configs)=loader.into_render_configs().map_err(LoadError::Io)?.consume();
-
-			let map=map_step2.add_render_configs_and_textures(
-				render_configs.into_iter(),
-				textures.into_iter().map(|(texture_id,texture)|
-					(texture_id,match texture{
-						strafesnet_deferred_loader::texture::Texture::ImageDDS(data)=>data,
-					})
-				),
-			);
-
-			Ok(map)
-		},
-	}
-}

src/graphics.rs

@@ -1,55 +1,59 @@
 use std::borrow::Cow;
-use std::collections::{HashSet,HashMap};
-use strafesnet_common::map;
-use strafesnet_common::integer;
-use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model_graphics::{self,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
+use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
 
-struct Indices{
+#[derive(Clone)]
-	count:u32,
+pub struct GraphicsModelUpdate{
-	buf:wgpu::Buffer,
+	transform:Option<glam::Mat4>,
-	format:wgpu::IndexFormat,
+	color:Option<glam::Vec4>,
 }
-impl Indices{
+
-	fn new<T:bytemuck::Pod>(device:&wgpu::Device,indices:&Vec<T>,format:wgpu::IndexFormat)->Self{
+struct Entity{
-		Self{
+	index_count:u32,
-			buf:device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+	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,
-			}),
+		});
-			count:indices.len() as u32,
+		Entity{
-			format,
+			index_buf,
+			index_count:indices.len() as u32,
 		}
-	}
+	}).collect()
-}
-struct GraphicsModel{
-	indices:Indices,
-	vertex_buf:wgpu::Buffer,
-	bind_group:wgpu::BindGroup,
-	instance_count:u32,
 }
 
-struct GraphicsSamplers{
+struct GraphicsModel{
+	entities:Vec<Entity>,
+	model_buf:wgpu::Buffer,
+	vertex_buf:wgpu::Buffer,
+	bind_group:wgpu::BindGroup,
+	index_format:wgpu::IndexFormat,
+	instances:Vec<GraphicsModelInstance>,
+}
+
+pub struct GraphicsSamplers{
 	repeat: wgpu::Sampler,
 }
 
-struct GraphicsBindGroupLayouts{
+pub struct GraphicsBindGroupLayouts{
 	model: wgpu::BindGroupLayout,
 }
 
-struct GraphicsBindGroups{
+pub struct GraphicsBindGroups {
 	camera: wgpu::BindGroup,
 	skybox_texture: wgpu::BindGroup,
 }
 
-struct GraphicsPipelines{
+pub struct GraphicsPipelines{
 	skybox: wgpu::RenderPipeline,
 	model: wgpu::RenderPipeline,
 }
 
-struct GraphicsCamera{
+pub struct GraphicsCamera{
 	screen_size: glam::UVec2,
 	fov: glam::Vec2,//slope
 	//camera angles and such are extrapolated and passed in every time
@@ -68,14 +72,14 @@ fn perspective_rh(fov_x_slope:f32,fov_y_slope:f32,z_near:f32,z_far:f32)->glam::M
 }
 impl GraphicsCamera{
 	pub fn proj(&self)->glam::Mat4{
-		perspective_rh(self.fov.x,self.fov.y,0.4,4000.0)
+		perspective_rh(self.fov.x, self.fov.y, 0.5, 2000.0)
 	}
 	pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
 		//f32 good enough for view matrix
 		glam::Mat4::from_translation(pos) * glam::Mat4::from_euler(glam::EulerRot::YXZ, angles.x, angles.y, 0f32)
 	}
 
-	pub fn to_uniform_data(&self,pos:glam::Vec3,angles:glam::Vec2)->[f32;16*4]{
+	pub fn to_uniform_data(&self,(pos,angles): (glam::Vec3,glam::Vec2)) -> [f32; 16 * 4] {
 		let proj=self.proj();
 		let proj_inv = proj.inverse();
 		let view_inv=self.world(pos,angles);
@@ -98,12 +102,6 @@ impl std::default::Default for GraphicsCamera{
 	}
 }
 
-pub struct FrameState{
-	pub body:crate::physics::Body,
-	pub camera:crate::physics::PhysicsCamera,
-	pub time:integer::Time,
-}
-
 pub struct GraphicsState{
 	pipelines: GraphicsPipelines,
 	bind_groups: GraphicsBindGroups,
@@ -146,17 +144,27 @@ impl GraphicsState{
 	pub fn load_user_settings(&mut self,user_settings:&crate::settings::UserSettings){
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
-	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
+	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,indexed_models:crate::model::IndexedModelInstances){
 		//generate texture view per texture
-		let texture_views:HashMap<strafesnet_common::model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
+
-			let texture_id=model::TextureId::new(texture_id as u32);
+		//idk how to do this gooder lol
-			let image=match ddsfile::Dds::read(std::io::Cursor::new(texture_data)){
+		let mut double_map=std::collections::HashMap::<u32,u32>::new();
-				Ok(image)=>image,
+		let mut texture_loading_threads=Vec::new();
-				Err(e)=>{
+		let num_textures=indexed_models.textures.len();
-					println!("Error loading texture: {e}");
+		for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
-					return None;
+			let path=std::path::PathBuf::from(format!("textures/{}.dds",texture_id));
-				},
+			if let Ok(mut file) = std::fs::File::open(path.clone()){
-			};
+				double_map.insert(i as u32, texture_loading_threads.len() as u32);
+				texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
+					ddsfile::Dds::read(&mut file).unwrap()
+				})));
+			}else{
+				//println!("missing texture path={:?}",path);
+			}
+		}
+
+		let texture_views:Vec<wgpu::TextureView>=texture_loading_threads.into_iter().map(|(texture_id,thread)|{
+			let image=thread.join().unwrap();
 
 			let (mut width,mut height)=(image.get_width(),image.get_height());
 
@@ -168,10 +176,7 @@ impl GraphicsState{
 					height=height/4*4;
 					wgpu::TextureFormat::Bc7RgbaUnormSrgb
 				},
-				other=>{
+				other=>panic!("unsupported format {:?}",other),
-					println!("unsupported texture format{:?}",other);
-					return None;
-				},
 			};
 
 			let size = wgpu::Extent3d {
@@ -195,82 +200,66 @@ impl GraphicsState{
 					dimension: wgpu::TextureDimension::D2,
 					format,
 					usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-					label:Some(format!("Texture{}",texture_id.get()).as_str()),
+					label: Some(format!("Texture{}",texture_id).as_str()),
 					view_formats: &[],
 				},
 				wgpu::util::TextureDataOrder::LayerMajor,
 				&image.data,
 			);
-			Some((texture_id,texture.create_view(&wgpu::TextureViewDescriptor{
+			texture.create_view(&wgpu::TextureViewDescriptor {
-				label:Some(format!("Texture{} View",texture_id.get()).as_str()),
+				label: Some(format!("Texture{} View",texture_id).as_str()),
 				dimension: Some(wgpu::TextureViewDimension::D2),
 				..wgpu::TextureViewDescriptor::default()
-			})))
+			})
 		}).collect();
-		let num_textures=texture_views.len();
 
 		//split groups with different textures into separate models
 		//the models received here are supposed to be tightly packed, i.e. no code needs to check if two models are using the same groups.
-		let indexed_models_len=map.models.len();
+		let indexed_models_len=indexed_models.models.len();
-		//models split into graphics_group.RenderConfigId
+		let mut unique_texture_models=Vec::with_capacity(indexed_models_len);
-		let mut owned_mesh_id_from_mesh_id_render_config_id:HashMap<model::MeshId,HashMap<RenderConfigId,IndexedGraphicsMeshOwnedRenderConfigId>>=HashMap::new();
+		for model in indexed_models.models.into_iter(){
-		let mut unique_render_config_models:Vec<IndexedGraphicsMeshOwnedRenderConfig>=Vec::with_capacity(indexed_models_len);
+			//convert ModelInstance into GraphicsModelInstance
-		for model in &map.models{
+			let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
-			//wow
+				if instance.color.w==0.0{
-			let instance=GraphicsModelOwned{
+					None
-				transform:model.transform.into(),
+				}else{
-				normal_transform:glam::Mat3::from_cols_array_2d(&model.transform.matrix3.to_array().map(|row|row.map(Into::into))).inverse().transpose(),
+					Some(GraphicsModelInstance{
-				color:GraphicsModelColor4::new(model.color),
+						transform: instance.transform.into(),
-			};
+						normal_transform: Into::<glam::Mat3>::into(instance.transform.matrix3).inverse().transpose(),
-			//get or create owned mesh map
+						color:GraphicsModelColor4::from(instance.color),
-			let owned_mesh_map=owned_mesh_id_from_mesh_id_render_config_id
-			.entry(model.mesh).or_insert_with(||{
-				let mut owned_mesh_map=HashMap::new();
-				//add mesh if renderid never before seen for this model
-				//add instance
-				//convert Model into GraphicsModelOwned
-				//check each group, if it's using a new render config then make a new clone of the model
-				if let Some(mesh)=map.meshes.get(model.mesh.get() as usize){
-					for graphics_group in mesh.graphics_groups.iter(){
-						//get or create owned mesh
-						let owned_mesh_id=owned_mesh_map
-						.entry(graphics_group.render).or_insert_with(||{
-							//create
-							let owned_mesh_id=IndexedGraphicsMeshOwnedRenderConfigId::new(unique_render_config_models.len() as u32);
-							unique_render_config_models.push(IndexedGraphicsMeshOwnedRenderConfig{
-								unique_pos:mesh.unique_pos.iter().map(|v|v.to_array().map(Into::into)).collect(),
-								unique_tex:mesh.unique_tex.iter().map(|v|*v.as_ref()).collect(),
-								unique_normal:mesh.unique_normal.iter().map(|v|v.to_array().map(Into::into)).collect(),
-								unique_color:mesh.unique_color.iter().map(|v|*v.as_ref()).collect(),
-								unique_vertices:mesh.unique_vertices.clone(),
-								render_config:graphics_group.render,
-								polys:model::PolygonGroup::PolygonList(model::PolygonList::new(Vec::new())),
-								instances:Vec::new(),
-							});
-							owned_mesh_id
-						});
-						let owned_mesh=unique_render_config_models.get_mut(owned_mesh_id.get() as usize).unwrap();
-						match &mut owned_mesh.polys{
-							model::PolygonGroup::PolygonList(polygon_list)=>polygon_list.extend(
-								graphics_group.groups.iter().flat_map(|polygon_group_id|{
-									mesh.polygon_groups[polygon_group_id.get() as usize].polys()
 					})
-								.map(|vertex_id_slice|
-									vertex_id_slice.to_vec()
-								)
-							),
 				}
-					}
+			}).collect();
-				}
+			//skip pushing a model if all instances are invisible
-				owned_mesh_map
+			if instances.len()==0{
-			});
-			for owned_mesh_id in owned_mesh_map.values(){
-				let owned_mesh=unique_render_config_models.get_mut(owned_mesh_id.get() as usize).unwrap();
-				let render_config=&map.render_configs[owned_mesh.render_config.get() as usize];
-				if model.color.w==0.0&&render_config.texture.is_none(){
 				continue;
 			}
-				owned_mesh.instances.push(instance.clone());
+			//check each group, if it's using a new texture then make a new clone of the model
+			let id=unique_texture_models.len();
+			let mut unique_textures=Vec::new();
+			for group in model.groups.into_iter(){
+				//ignore zero copy optimization for now
+				let texture_index=if let Some(texture_index)=unique_textures.iter().position(|&texture|texture==group.texture){
+					texture_index
+				}else{
+					//create new texture_index
+					let texture_index=unique_textures.len();
+					unique_textures.push(group.texture);
+					unique_texture_models.push(IndexedGraphicsModelSingleTexture{
+						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(),
+						unique_color:model.unique_color.iter().map(|v|*v.as_ref()).collect(),
+						unique_vertices:model.unique_vertices.clone(),
+						texture:group.texture,
+						groups:Vec::new(),
+						instances:instances.clone(),
+					});
+					texture_index
+				};
+				unique_texture_models[id+texture_index].groups.push(IndexedGroupFixedTexture{
+					polys:group.polys,
+				});
 			}
 		}
 		//check every model to see if it's using the same (texture,color) but has few instances, if it is combine it into one model
@@ -283,43 +272,53 @@ impl GraphicsState{
 
 		//for now: just deduplicate single models...
 		let mut deduplicated_models=Vec::with_capacity(indexed_models_len);//use indexed_models_len because the list will likely get smaller instead of bigger
-		let mut unique_texture_color=HashMap::new();//texture->color->vec![(model_id,instance_id)]
+		let mut unique_texture_color=std::collections::HashMap::new();//texture->color->vec![(model_id,instance_id)]
-		for (model_id,model) in unique_render_config_models.iter().enumerate(){
+		for (model_id,model) in unique_texture_models.iter().enumerate(){
 			//for now: filter out models with more than one instance
 			if 1<model.instances.len(){
 				continue;
 			}
 			//populate hashmap
-			let unique_color=unique_texture_color
+			let unique_color=if let Some(unique_color)=unique_texture_color.get_mut(&model.texture){
-			.entry(model.render_config)
+				unique_color
-			.or_insert_with(||HashMap::new());
+			}else{
+				//make new hashmap
+				let unique_color=std::collections::HashMap::new();
+				unique_texture_color.insert(model.texture,unique_color);
+				unique_texture_color.get_mut(&model.texture).unwrap()
+			};
 			//separate instances by color
 			for (instance_id,instance) in model.instances.iter().enumerate(){
-				let model_instance_list=unique_color
+				let model_instance_list=if let Some(model_instance_list)=unique_color.get_mut(&instance.color){
-				.entry(instance.color)
+					model_instance_list
-				.or_insert_with(||Vec::new());
+				}else{
+					//make new hashmap
+					let model_instance_list=Vec::new();
+					unique_color.insert(instance.color.clone(),model_instance_list);
+					unique_color.get_mut(&instance.color).unwrap()
+				};
 				//add model instance to list
 				model_instance_list.push((model_id,instance_id));
 			}
 		}
 		//populate a hashset of models selected for transposition
 		//construct transposed models
-		let mut selected_model_instances=HashSet::new();
+		let mut selected_model_instances=std::collections::HashSet::new();
-		for (render_config,unique_color) in unique_texture_color.into_iter(){
+		for (texture,unique_color) in unique_texture_color.into_iter(){
 			for (color,model_instance_list) in unique_color.into_iter(){
 				//world transforming one model does not meet the definition of deduplicaiton
 				if 1<model_instance_list.len(){
 					//create model
 					let mut unique_pos=Vec::new();
-					let mut pos_id_from=HashMap::new();
+					let mut pos_id_from=std::collections::HashMap::new();
 					let mut unique_tex=Vec::new();
-					let mut tex_id_from=HashMap::new();
+					let mut tex_id_from=std::collections::HashMap::new();
 					let mut unique_normal=Vec::new();
-					let mut normal_id_from=HashMap::new();
+					let mut normal_id_from=std::collections::HashMap::new();
 					let mut unique_color=Vec::new();
-					let mut color_id_from=HashMap::new();
+					let mut color_id_from=std::collections::HashMap::new();
 					let mut unique_vertices=Vec::new();
-					let mut vertex_id_from=HashMap::new();
+					let mut vertex_id_from=std::collections::HashMap::new();
 
 					let mut polys=Vec::new();
 					//transform instance vertices
@@ -327,74 +326,91 @@ impl GraphicsState{
 						//populate hashset to prevent these models from being copied
 						selected_model_instances.insert(model_id);
 						//there is only one instance per model
-						let model=&unique_render_config_models[model_id];
+						let model=&unique_texture_models[model_id];
 						let instance=&model.instances[instance_id];
 						//just hash word slices LOL
-						let map_pos_id:Vec<PositionId>=model.unique_pos.iter().map(|untransformed_pos|{
+						let map_pos_id:Vec<u32>=model.unique_pos.iter().map(|untransformed_pos|{
 							let pos=instance.transform.transform_point3(glam::Vec3::from_array(untransformed_pos.clone())).to_array();
-							let h=bytemuck::cast::<[f32;3],[u32;3]>(pos);
+							let h=pos.map(|v|bytemuck::cast::<f32,u32>(v));
-							PositionId::new(*pos_id_from.entry(h).or_insert_with(||{
+							(if let Some(&pos_id)=pos_id_from.get(&h){
-								let pos_id=unique_pos.len();
-								unique_pos.push(pos);
 								pos_id
-							}) as u32)
+							}else{
+								let pos_id=unique_pos.len();
+								unique_pos.push(pos.clone());
+								pos_id_from.insert(h,pos_id);
+								pos_id
+							}) as u32
 						}).collect();
-						let map_tex_id:Vec<TextureCoordinateId>=model.unique_tex.iter().map(|&tex|{
+						let map_tex_id:Vec<u32>=model.unique_tex.iter().map(|tex|{
-							let h=bytemuck::cast::<[f32;2],[u32;2]>(tex);
+							let h=tex.map(|v|bytemuck::cast::<f32,u32>(v));
-							TextureCoordinateId::new(*tex_id_from.entry(h).or_insert_with(||{
+							(if let Some(&tex_id)=tex_id_from.get(&h){
-								let tex_id=unique_tex.len();
-								unique_tex.push(tex);
 								tex_id
-							}) as u32)
+							}else{
+								let tex_id=unique_tex.len();
+								unique_tex.push(tex.clone());
+								tex_id_from.insert(h,tex_id);
+								tex_id
+							}) as u32
 						}).collect();
-						let map_normal_id:Vec<NormalId>=model.unique_normal.iter().map(|untransformed_normal|{
+						let map_normal_id:Vec<u32>=model.unique_normal.iter().map(|untransformed_normal|{
 							let normal=(instance.normal_transform*glam::Vec3::from_array(untransformed_normal.clone())).to_array();
-							let h=bytemuck::cast::<[f32;3],[u32;3]>(normal);
+							let h=normal.map(|v|bytemuck::cast::<f32,u32>(v));
-							NormalId::new(*normal_id_from.entry(h).or_insert_with(||{
+							(if let Some(&normal_id)=normal_id_from.get(&h){
-								let normal_id=unique_normal.len();
-								unique_normal.push(normal);
 								normal_id
-							}) as u32)
+							}else{
+								let normal_id=unique_normal.len();
+								unique_normal.push(normal.clone());
+								normal_id_from.insert(h,normal_id);
+								normal_id
+							}) as u32
 						}).collect();
-						let map_color_id:Vec<ColorId>=model.unique_color.iter().map(|&color|{
+						let map_color_id:Vec<u32>=model.unique_color.iter().map(|color|{
-							let h=bytemuck::cast::<[f32;4],[u32;4]>(color);
+							let h=color.map(|v|bytemuck::cast::<f32,u32>(v));
-							ColorId::new(*color_id_from.entry(h).or_insert_with(||{
+							(if let Some(&color_id)=color_id_from.get(&h){
-								let color_id=unique_color.len();
-								unique_color.push(color);
 								color_id
-							}) as u32)
+							}else{
+								let color_id=unique_color.len();
+								unique_color.push(color.clone());
+								color_id_from.insert(h,color_id);
+								color_id
+							}) as u32
 						}).collect();
 						//map the indexed vertices onto new indices
 						//creating the vertex map is slightly different because the vertices are directly hashable
-						let map_vertex_id:Vec<VertexId>=model.unique_vertices.iter().map(|unmapped_vertex|{
+						let map_vertex_id:Vec<u32>=model.unique_vertices.iter().map(|unmapped_vertex|{
-							let vertex=model::IndexedVertex{
+							let vertex=crate::model::IndexedVertex{
-								pos:map_pos_id[unmapped_vertex.pos.get() as usize],
+								pos:map_pos_id[unmapped_vertex.pos as usize],
-								tex:map_tex_id[unmapped_vertex.tex.get() as usize],
+								tex:map_tex_id[unmapped_vertex.tex as usize],
-								normal:map_normal_id[unmapped_vertex.normal.get() as usize],
+								normal:map_normal_id[unmapped_vertex.normal as usize],
-								color:map_color_id[unmapped_vertex.color.get() as usize],
+								color:map_color_id[unmapped_vertex.color as usize],
 							};
-							VertexId::new(*vertex_id_from.entry(vertex.clone()).or_insert_with(||{
+							(if let Some(&vertex_id)=vertex_id_from.get(&vertex){
-								let vertex_id=unique_vertices.len();
-								unique_vertices.push(vertex);
 								vertex_id
-							}) as u32)
+							}else{
+								let vertex_id=unique_vertices.len();
+								unique_vertices.push(vertex.clone());
+								vertex_id_from.insert(vertex,vertex_id);
+								vertex_id
+							}) as u32
 						}).collect();
-						polys.extend(model.polys.polys().map(|poly|
+						for group in &model.groups{
-							poly.iter().map(|vertex_id|
+							for poly in &group.polys{
-								map_vertex_id[vertex_id.get() as usize]
+								polys.push(crate::model::IndexedPolygon{vertices:poly.vertices.iter().map(|&vertex_id|map_vertex_id[vertex_id as usize]).collect()});
-							).collect()
+							}
-						));
+						}
 					}
 					//push model into dedup
-					deduplicated_models.push(IndexedGraphicsMeshOwnedRenderConfig{
+					deduplicated_models.push(IndexedGraphicsModelSingleTexture{
 						unique_pos,
 						unique_tex,
 						unique_normal,
 						unique_color,
 						unique_vertices,
-						render_config,
+						texture,
-						polys:model::PolygonGroup::PolygonList(model::PolygonList::new(polys)),
+						groups:vec![IndexedGroupFixedTexture{
-						instances:vec![GraphicsModelOwned{
+							polys
+						}],
+						instances:vec![GraphicsModelInstance{
 							transform:glam::Mat4::IDENTITY,
 							normal_transform:glam::Mat3::IDENTITY,
 							color
@@ -404,7 +420,7 @@ impl GraphicsState{
 			}
 		}
 		//fill untouched models
-		for (model_id,model) in unique_render_config_models.into_iter().enumerate(){
+		for (model_id,model) in unique_texture_models.into_iter().enumerate(){
 			if !selected_model_instances.contains(&model_id){
 				deduplicated_models.push(model);
 			}
@@ -412,44 +428,45 @@ impl GraphicsState{
 
 		//de-index models
 		let deduplicated_models_len=deduplicated_models.len();
-		let models:Vec<GraphicsMeshOwnedRenderConfig>=deduplicated_models.into_iter().map(|model|{
+		let models:Vec<GraphicsModelSingleTexture>=deduplicated_models.into_iter().map(|model|{
 			let mut vertices = Vec::new();
-			let mut index_from_vertex=HashMap::new();//::<IndexedVertex,usize>
+			let mut index_from_vertex = std::collections::HashMap::new();//::<IndexedVertex,usize>
 			//this mut be combined in a more complex way if the models use different render patterns per group
 				let mut indices = Vec::new();
-			for poly in model.polys.polys(){
+			for group in model.groups {
-				let mut poly_vertices=poly.iter()
+				for poly in group.polys {
-				.map(|&vertex_index|*index_from_vertex.entry(vertex_index).or_insert_with(||{
+					for end_index in 2..poly.vertices.len() {
+						for &index in &[0, end_index - 1, end_index] {
+							let vertex_index = poly.vertices[index];
+							if let Some(&i)=index_from_vertex.get(&vertex_index){
+								indices.push(i);
+							}else{
 								let i=vertices.len();
-					let vertex=&model.unique_vertices[vertex_index.get() as usize];
+								let vertex=&model.unique_vertices[vertex_index as usize];
 								vertices.push(GraphicsVertex{
-						pos:model.unique_pos[vertex.pos.get() as usize],
+									pos: model.unique_pos[vertex.pos as usize],
-						tex:model.unique_tex[vertex.tex.get() as usize],
+									tex: model.unique_tex[vertex.tex as usize],
-						normal:model.unique_normal[vertex.normal.get() as usize],
+									normal: model.unique_normal[vertex.normal as usize],
-						color:model.unique_color[vertex.color.get() as usize],
+									color:model.unique_color[vertex.color as usize],
-					});
-					i
-				}));
-
-				let a=poly_vertices.next().unwrap();
-				let mut b=poly_vertices.next().unwrap();
-
-				poly_vertices.for_each(|c|{
-					indices.extend([a,b,c]);
-					b=c;
 								});
+								index_from_vertex.insert(vertex_index,i);
+								indices.push(i);
 							}
-			GraphicsMeshOwnedRenderConfig{
+						}
+					}
+				}
+			}
+			GraphicsModelSingleTexture{
 				instances:model.instances,
-				indices:if (u32::MAX as usize)<vertices.len(){
+				entities:if (u32::MAX as usize)<vertices.len(){
 					panic!("Model has too many vertices!")
 				}else if (u16::MAX as usize)<vertices.len(){
-					model_graphics::Indices::U32(indices.into_iter().map(|vertex_idx|vertex_idx as u32).collect())
+					crate::model_graphics::Entities::U32(vec![indices.into_iter().map(|vertex_id|vertex_id as u32).collect()])
 				}else{
-					model_graphics::Indices::U16(indices.into_iter().map(|vertex_idx|vertex_idx as u16).collect())
+					crate::model_graphics::Entities::U16(vec![indices.into_iter().map(|vertex_id|vertex_id as u16).collect()])
 				},
 				vertices,
-				render_config:model.render_config,
+				texture:model.texture,
 			}
 		}).collect();
 		//.into_iter() the modeldata vec so entities can be /moved/ to models.entities
@@ -462,19 +479,22 @@ impl GraphicsState{
 			instance_count+=model.instances.len();
 			for instances_chunk in model.instances.rchunks(chunk_size){
 				model_count+=1;
-				let mut model_uniforms=get_instances_buffer_data(instances_chunk);
+				let model_uniforms = get_instances_buffer_data(instances_chunk);
-				//TEMP: fill with zeroes to pass validation
-				model_uniforms.resize(MODEL_BUFFER_SIZE*512,0.0f32);
 				let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 					label: Some(format!("Model{} Buf",model_count).as_str()),
 					contents: bytemuck::cast_slice(&model_uniforms),
 					usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
 				});
-				let render_config=&map.render_configs[model.render_config.get() as usize];
+				let texture_view=match model.texture{
-				let texture_view=render_config.texture.and_then(|texture_id|
+					Some(texture_id)=>{
-					texture_views.get(&texture_id)
+						match double_map.get(&texture_id){
-				).unwrap_or(&self.temp_squid_texture_view);
+							Some(&mapped_texture_id)=>&texture_views[mapped_texture_id as usize],
-				let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
+							None=>&self.temp_squid_texture_view,
+						}
+					},
+					None=>&self.temp_squid_texture_view,
+				};
+				let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
 					layout: &self.bind_group_layouts.model,
 					entries: &[
 						wgpu::BindGroupEntry {
@@ -499,13 +519,18 @@ impl GraphicsState{
 				});
 				//all of these are being moved here
 				self.models.push(GraphicsModel{
-					instance_count:instances_chunk.len() as u32,
+					instances:instances_chunk.to_vec(),
 					vertex_buf,
-					indices:match &model.indices{
+					index_format:match &model.entities{
-						model_graphics::Indices::U32(indices)=>Indices::new(device,indices,wgpu::IndexFormat::Uint32),
+						crate::model_graphics::Entities::U32(_)=>wgpu::IndexFormat::Uint32,
-						model_graphics::Indices::U16(indices)=>Indices::new(device,indices,wgpu::IndexFormat::Uint16),
+						crate::model_graphics::Entities::U16(_)=>wgpu::IndexFormat::Uint16,
 					},
-					bind_group,
+					entities:match &model.entities{
+						crate::model_graphics::Entities::U32(entities)=>create_entities(device,entities),
+						crate::model_graphics::Entities::U16(entities)=>create_entities(device,entities),
+					},
+					bind_group: model_bind_group,
+					model_buf,
 				});
 			}
 		}
@@ -754,13 +779,11 @@ impl GraphicsState{
 				module: &shader,
 				entry_point: "vs_sky",
 				buffers: &[],
-				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			},
 			fragment: Some(wgpu::FragmentState {
 				module: &shader,
 				entry_point: "fs_sky",
 				targets: &[Some(config.view_formats[0].into())],
-				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			}),
 			primitive: wgpu::PrimitiveState {
 				front_face: wgpu::FrontFace::Cw,
@@ -775,7 +798,6 @@ impl GraphicsState{
 			}),
 			multisample: wgpu::MultisampleState::default(),
 			multiview: None,
-			cache:None,
 		});
 		let model_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
 			label: Some("Model Pipeline"),
@@ -788,13 +810,11 @@ impl GraphicsState{
 					step_mode: wgpu::VertexStepMode::Vertex,
 					attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x3, 3 => Float32x4],
 				}],
-				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			},
 			fragment: Some(wgpu::FragmentState {
 				module: &shader,
 				entry_point: "fs_entity_texture",
 				targets: &[Some(config.view_formats[0].into())],
-				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			}),
 			primitive: wgpu::PrimitiveState {
 				front_face: wgpu::FrontFace::Cw,
@@ -810,11 +830,10 @@ impl GraphicsState{
 			}),
 			multisample: wgpu::MultisampleState::default(),
 			multiview: None,
-			cache:None,
 		});
 
 		let camera=GraphicsCamera::default();
-		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::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),
@@ -882,17 +901,17 @@ impl GraphicsState{
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		frame_state:FrameState,
+		physics_output:crate::physics::PhysicsOutputState,
+		predicted_time:crate::integer::Time,
+		mouse_pos:glam::IVec2,
 	) {
 		//TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
 
-		let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
+		let mut encoder =
+			device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 
 		// update rotation
-		let camera_uniforms=self.camera.to_uniform_data(
+		let camera_uniforms = self.camera.to_uniform_data(physics_output.extrapolate(mouse_pos,predicted_time));
-			frame_state.body.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
-			frame_state.camera.simulate_move_angles(glam::IVec2::ZERO)
-		);
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,
@@ -951,12 +970,14 @@ impl GraphicsState{
 			rpass.set_bind_group(1, &self.bind_groups.skybox_texture, &[]);
 
 			rpass.set_pipeline(&self.pipelines.model);
-			for model in &self.models{
+			for model in self.models.iter() {
 				rpass.set_bind_group(2, &model.bind_group, &[]);
 				rpass.set_vertex_buffer(0, model.vertex_buf.slice(..));
-				rpass.set_index_buffer(model.indices.buf.slice(..),model.indices.format);
+
-				//TODO: loop over triangle strips
+				for entity in model.entities.iter(){
-				rpass.draw_indexed(0..model.indices.count,0,0..model.instance_count);
+					rpass.set_index_buffer(entity.index_buf.slice(..),model.index_format);
+					rpass.draw_indexed(0..entity.index_count,0,0..model.instances.len() as u32);
+				}
 			}
 
 			rpass.set_pipeline(&self.pipelines.skybox);
@@ -970,9 +991,10 @@ 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:&[GraphicsModelOwned])->Vec<f32>{
+fn get_instances_buffer_data(instances:&[GraphicsModelInstance]) -> Vec<f32> {
 	let mut raw = Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
-	for mi in instances{
+	for (i,mi) in instances.iter().enumerate(){
+		let mut v = raw.split_off(MODEL_BUFFER_SIZE*i);
 		//model transform
 		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
 		//normal transform
@@ -984,6 +1006,7 @@ fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
 		raw.extend_from_slice(&[0.0]);
 		//color
 		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
+		raw.append(&mut v);
 	}
 	raw
 }

src/graphics_worker.rs

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

src/instruction.rs

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

src/load_bsp.rs

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

src/load_roblox.rs

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

src/main.rs

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

src/model.rs

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

src/model_graphics.rs

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

src/model_physics.rs

@@ -1,15 +1,22 @@
+use crate::integer::{Planar64,Planar64Vec3};
 use std::borrow::{Borrow,Cow};
-use std::collections::{HashSet,HashMap};
-use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::model::{self,MeshId,PolygonIter};
-use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 
+#[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+std::fmt::Debug+UndirectedEdge;
+	type UndirectedEdge:Copy+UndirectedEdge;
 	fn as_undirected(&self)->Self::UndirectedEdge;
 	fn parity(&self)->bool;
 	//this is stupid but may work fine
@@ -17,40 +24,22 @@ pub trait DirectedEdge{
 		self.as_undirected().as_directed(!self.parity())
 	}
 }
-
-#[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct MeshVertId(u32);
-#[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct MeshFaceId(u32);
-
-#[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct SubmeshVertId(u32);
-#[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct SubmeshEdgeId(u32);
 /// DirectedEdgeId refers to an EdgeId when undirected.
-#[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub struct SubmeshDirectedEdgeId(u32);
+pub struct DirectedEdgeId(usize);
-#[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
+impl DirectedEdge for DirectedEdgeId{
-pub struct SubmeshFaceId(u32);
+	type UndirectedEdge=EdgeId;
-
+	fn as_undirected(&self)->EdgeId{
-impl UndirectedEdge for SubmeshEdgeId{
+		EdgeId(self.0&!(1<<(usize::BITS-1)))
-	type DirectedEdge=SubmeshDirectedEdgeId;
-	fn as_directed(&self,parity:bool)->SubmeshDirectedEdgeId{
-		SubmeshDirectedEdgeId(self.0|((parity as u32)<<(u32::BITS-1)))
-	}
-}
-impl DirectedEdge for SubmeshDirectedEdgeId{
-	type UndirectedEdge=SubmeshEdgeId;
-	fn as_undirected(&self)->SubmeshEdgeId{
-		SubmeshEdgeId(self.0&!(1<<(u32::BITS-1)))
 	}
 	fn parity(&self)->bool{
-		self.0&(1<<(u32::BITS-1))!=0
+		self.0&(1<<(usize::BITS-1))!=0
 	}
 }
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub struct FaceId(usize);
 
 //Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug)]
 pub enum FEV<F,E:DirectedEdge,V>{
 	Face(F),
 	Edge(E::UndirectedEdge),
@@ -58,16 +47,12 @@ pub enum FEV<F,E:DirectedEdge,V>{
 }
 
 //use Unit32 #[repr(C)] for map files
-#[derive(Clone,Hash,Eq,PartialEq)]
 struct Face{
 	normal:Planar64Vec3,
 	dot:Planar64,
 }
 struct Vert(Planar64Vec3);
 pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
-	// Vertex must be Planar64Vec3 because it represents an actual position
-	type Normal;
-	type Offset;
 	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())
@@ -77,7 +62,7 @@ pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
 		(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)->(Self::Normal,Self::Offset);
+	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]>;
@@ -85,170 +70,34 @@ pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
 	fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
 }
 struct FaceRefs{
-	edges:Vec<SubmeshDirectedEdgeId>,
+	edges:Vec<DirectedEdgeId>,
 	//verts:Vec<VertId>,
 }
 struct EdgeRefs{
-	faces:[SubmeshFaceId;2],//left, right
+	faces:[FaceId;2],//left, right
-	verts:[SubmeshVertId;2],//bottom, top
+	verts:[VertId;2],//bottom, top
 }
 struct VertRefs{
-	faces:Vec<SubmeshFaceId>,
+	faces:Vec<FaceId>,
-	edges:Vec<SubmeshDirectedEdgeId>,
+	edges:Vec<DirectedEdgeId>,
 }
-pub struct PhysicsMeshData{
+pub struct PhysicsMesh{
-	//this contains all real and virtual faces used in both the complete mesh and convex submeshes
+	faces:Vec<Face>,
-	//faces are sorted such that all faces that belong to the complete mesh appear first, and then
+	verts:Vec<Vert>,
-	//all remaining faces are virtual to operate internal logic of the face crawler
-	//and cannot be part of a physics collision
-	//virtual faces are only used in convex submeshes.
-	faces:Vec<Face>,//MeshFaceId indexes this list
-	verts:Vec<Vert>,//MeshVertId indexes this list
-}
-pub struct PhysicsMeshTopology{
-	//mapping of local ids to PhysicsMeshData ids
-	faces:Vec<MeshFaceId>,//SubmeshFaceId indexes this list
-	verts:Vec<MeshVertId>,//SubmeshVertId indexes this list
-	//all ids here are local to this object
 	face_topology:Vec<FaceRefs>,
 	edge_topology:Vec<EdgeRefs>,
 	vert_topology:Vec<VertRefs>,
 }
-#[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct PhysicsMeshId(u32);
-impl Into<MeshId> for PhysicsMeshId{
-	fn into(self)->MeshId{
-		MeshId::new(self.0)
-	}
-}
-impl From<MeshId> for PhysicsMeshId{
-	fn from(value:MeshId)->Self{
-		Self::new(value.get())
-	}
-}
-#[derive(Debug,Default,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct PhysicsSubmeshId(u32);
-pub struct PhysicsMesh{
-	data:PhysicsMeshData,
-	complete_mesh:PhysicsMeshTopology,
-	//Most objects in roblox maps are already convex, so the list length is 0
-	//as soon as the mesh is divided into 2 submeshes, the list length jumps to 2.
-	//length 1 is unnecessary since the complete mesh would be a duplicate of the only submesh, but would still function properly
-	submeshes:Vec<PhysicsMeshTopology>,
-}
-impl PhysicsMesh{
-	pub fn unit_cube()->Self{
-		//go go gadget debug print mesh
-		let data=PhysicsMeshData{
-			faces:vec![
-				Face{normal:vec3::raw_xyz( 4294967296, 0, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:vec3::raw_xyz( 0, 4294967296, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:vec3::raw_xyz( 0, 0, 4294967296),dot:Planar64::raw(4294967296)},
-				Face{normal:vec3::raw_xyz(-4294967296, 0, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:vec3::raw_xyz( 0,-4294967296, 0),dot:Planar64::raw(4294967296)},
-				Face{normal:vec3::raw_xyz( 0, 0,-4294967296),dot:Planar64::raw(4294967296)}
-			],
-			verts:vec![
-				Vert(vec3::raw_xyz( 4294967296,-4294967296,-4294967296)),
-				Vert(vec3::raw_xyz( 4294967296, 4294967296,-4294967296)),
-				Vert(vec3::raw_xyz( 4294967296, 4294967296, 4294967296)),
-				Vert(vec3::raw_xyz( 4294967296,-4294967296, 4294967296)),
-				Vert(vec3::raw_xyz(-4294967296, 4294967296,-4294967296)),
-				Vert(vec3::raw_xyz(-4294967296, 4294967296, 4294967296)),
-				Vert(vec3::raw_xyz(-4294967296,-4294967296, 4294967296)),
-				Vert(vec3::raw_xyz(-4294967296,-4294967296,-4294967296))
-			]
-		};
-		let mesh_topology=PhysicsMeshTopology{
-			faces:(0..data.faces.len() as u32).map(MeshFaceId::new).collect(),
-			verts:(0..data.verts.len() as u32).map(MeshVertId::new).collect(),
-			face_topology:vec![
-				FaceRefs{edges:vec![SubmeshDirectedEdgeId((9223372036854775808u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775809u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775810u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(3)]},
-				FaceRefs{edges:vec![SubmeshDirectedEdgeId((9223372036854775812u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775813u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(6),SubmeshDirectedEdgeId(1)]},
-				FaceRefs{edges:vec![SubmeshDirectedEdgeId(7),SubmeshDirectedEdgeId(2),SubmeshDirectedEdgeId((9223372036854775814u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775816u64-(1<<63)+(1<<31)) as u32)]},
-				FaceRefs{edges:vec![SubmeshDirectedEdgeId(8),SubmeshDirectedEdgeId(5),SubmeshDirectedEdgeId((9223372036854775817u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(10)]},
-				FaceRefs{edges:vec![SubmeshDirectedEdgeId((9223372036854775815u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775818u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(11),SubmeshDirectedEdgeId((9223372036854775811u64-(1<<63)+(1<<31)) as u32)]},
-				FaceRefs{edges:vec![SubmeshDirectedEdgeId(4),SubmeshDirectedEdgeId(0),SubmeshDirectedEdgeId((9223372036854775819u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(9)]}
-			],
-			edge_topology:vec![
-				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(5)],verts:[SubmeshVertId(0),SubmeshVertId(1)]},
-				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(1)],verts:[SubmeshVertId(1),SubmeshVertId(2)]},
-				EdgeRefs{faces:[SubmeshFaceId(0),SubmeshFaceId(2)],verts:[SubmeshVertId(2),SubmeshVertId(3)]},
-				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(0)],verts:[SubmeshVertId(0),SubmeshVertId(3)]},
-				EdgeRefs{faces:[SubmeshFaceId(1),SubmeshFaceId(5)],verts:[SubmeshVertId(1),SubmeshVertId(4)]},
-				EdgeRefs{faces:[SubmeshFaceId(1),SubmeshFaceId(3)],verts:[SubmeshVertId(4),SubmeshVertId(5)]},
-				EdgeRefs{faces:[SubmeshFaceId(2),SubmeshFaceId(1)],verts:[SubmeshVertId(2),SubmeshVertId(5)]},
-				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(2)],verts:[SubmeshVertId(3),SubmeshVertId(6)]},
-				EdgeRefs{faces:[SubmeshFaceId(2),SubmeshFaceId(3)],verts:[SubmeshVertId(5),SubmeshVertId(6)]},
-				EdgeRefs{faces:[SubmeshFaceId(3),SubmeshFaceId(5)],verts:[SubmeshVertId(4),SubmeshVertId(7)]},
-				EdgeRefs{faces:[SubmeshFaceId(4),SubmeshFaceId(3)],verts:[SubmeshVertId(6),SubmeshVertId(7)]},
-				EdgeRefs{faces:[SubmeshFaceId(5),SubmeshFaceId(4)],verts:[SubmeshVertId(0),SubmeshVertId(7)]}
-			],
-			vert_topology:vec![
-				VertRefs{faces:vec![SubmeshFaceId(0),SubmeshFaceId(4),SubmeshFaceId(5)],edges:vec![SubmeshDirectedEdgeId((9223372036854775811u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775819u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775808u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(0),SubmeshFaceId(5),SubmeshFaceId(1)],edges:vec![SubmeshDirectedEdgeId((9223372036854775812u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId(0),SubmeshDirectedEdgeId((9223372036854775809u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(0),SubmeshFaceId(2),SubmeshFaceId(1)],edges:vec![SubmeshDirectedEdgeId(1),SubmeshDirectedEdgeId((9223372036854775810u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775814u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(0),SubmeshFaceId(2),SubmeshFaceId(4)],edges:vec![SubmeshDirectedEdgeId(2),SubmeshDirectedEdgeId(3),SubmeshDirectedEdgeId((9223372036854775815u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(3),SubmeshFaceId(5),SubmeshFaceId(1)],edges:vec![SubmeshDirectedEdgeId(4),SubmeshDirectedEdgeId((9223372036854775817u64-(1<<63)+(1<<31)) as u32),SubmeshDirectedEdgeId((9223372036854775813u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(2),SubmeshFaceId(3),SubmeshFaceId(1)],edges:vec![SubmeshDirectedEdgeId(5),SubmeshDirectedEdgeId(6),SubmeshDirectedEdgeId((9223372036854775816u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(2),SubmeshFaceId(3),SubmeshFaceId(4)],edges:vec![SubmeshDirectedEdgeId(7),SubmeshDirectedEdgeId(8),SubmeshDirectedEdgeId((9223372036854775818u64-(1<<63)+(1<<31)) as u32)]},
-				VertRefs{faces:vec![SubmeshFaceId(4),SubmeshFaceId(3),SubmeshFaceId(5)],edges:vec![SubmeshDirectedEdgeId(10),SubmeshDirectedEdgeId(11),SubmeshDirectedEdgeId(9)]}
-			]
-		};
-		Self{
-			data,
-			complete_mesh:mesh_topology,
-			submeshes:Vec::new(),
-		}
-	}
-	pub fn unit_cylinder()->Self{
-		Self::unit_cube()
-	}
-	#[inline]
-	pub const fn complete_mesh(&self)->&PhysicsMeshTopology{
-		&self.complete_mesh
-	}
-	#[inline]
-	pub const fn complete_mesh_view(&self)->PhysicsMeshView{
-		PhysicsMeshView{
-			data:&self.data,
-			topology:self.complete_mesh(),
-		}
-	}
-	#[inline]
-	pub fn submeshes(&self)->&[PhysicsMeshTopology]{
-		//the complete mesh is already a convex mesh when len()==0, len()==1 is invalid but will still work
-		if self.submeshes.len()==0{
-			std::slice::from_ref(&self.complete_mesh)
-		}else{
-			&self.submeshes.as_slice()
-		}
-	}
-	#[inline]
-	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView{
-		PhysicsMeshView{
-			data:&self.data,
-			topology:&self.submeshes()[submesh_id.get() as usize],
-		}
-	}
-	pub fn submesh_views(&self)->impl Iterator<Item=PhysicsMeshView>{
-		self.submeshes().iter().map(|topology|PhysicsMeshView{
-			data:&self.data,
-			topology,
-		})
-	}
-}
 
-//mesh builder code
 #[derive(Default,Clone)]
 struct VertRefGuy{
-	edges:HashSet<SubmeshDirectedEdgeId>,
+	edges:std::collections::HashSet<DirectedEdgeId>,
-	faces:HashSet<SubmeshFaceId>,
+	faces:std::collections::HashSet<FaceId>,
 }
 #[derive(Clone,Hash,Eq,PartialEq)]
-struct EdgeRefVerts([SubmeshVertId;2]);
+struct EdgeRefVerts([VertId;2]);
 impl EdgeRefVerts{
-	const fn new(v0:SubmeshVertId,v1:SubmeshVertId)->(Self,bool){
+	fn new(v0:VertId,v1:VertId)->(Self,bool){
 		(if v0.0<v1.0{
 			Self([v0,v1])
 		}else{
@@ -256,142 +105,89 @@ impl EdgeRefVerts{
 		},v0.0<v1.0)
 	}
 }
-struct EdgeRefFaces([SubmeshFaceId;2]);
+struct EdgeRefFaces([FaceId;2]);
 impl EdgeRefFaces{
-	const fn new()->Self{
+	fn new()->Self{
-		Self([SubmeshFaceId(0);2])
+		Self([FaceId(0);2])
 	}
-	fn push(&mut self,i:usize,face_id:SubmeshFaceId){
+	fn push(&mut self,i:usize,face_id:FaceId){
 		self.0[i]=face_id;
 	}
 }
-struct FaceRefEdges(Vec<SubmeshDirectedEdgeId>);
+struct FaceRefEdges(Vec<DirectedEdgeId>);
 #[derive(Default)]
 struct EdgePool{
 	edge_guys:Vec<(EdgeRefVerts,EdgeRefFaces)>,
-	edge_id_from_guy:HashMap<EdgeRefVerts,SubmeshEdgeId>,
+	edge_id_from_guy:std::collections::HashMap<EdgeRefVerts,usize>,
 }
 impl EdgePool{
-	fn push(&mut self,edge_ref_verts:EdgeRefVerts)->(&mut EdgeRefFaces,SubmeshEdgeId){
+	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=SubmeshEdgeId::new(self.edge_guys.len() as u32);
+			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.get() as usize)}.1,edge_id)
+		(&mut unsafe{self.edge_guys.get_unchecked_mut(edge_id)}.1,EdgeId(edge_id))
 	}
 }
-
+impl From<&crate::model::IndexedModel> for PhysicsMesh{
-#[derive(Debug)]
+	fn from(indexed_model:&crate::model::IndexedModel)->Self{
-pub enum PhysicsMeshError{
+		assert!(indexed_model.unique_pos.len()!=0,"Mesh cannot have 0 vertices");
-	ZeroVertices,
+		let verts=indexed_model.unique_pos.iter().map(|v|Vert(v.clone())).collect();
-	NoPhysicsGroups,
+		let mut vert_ref_guys=vec![VertRefGuy::default();indexed_model.unique_pos.len()];
-}
-impl std::fmt::Display for PhysicsMeshError{
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for PhysicsMeshError{}
-
-impl TryFrom<&model::Mesh> for PhysicsMesh{
-	type Error=PhysicsMeshError;
-	fn try_from(mesh:&model::Mesh)->Result<Self,PhysicsMeshError>{
-		if mesh.unique_pos.len()==0{
-			return Err(PhysicsMeshError::ZeroVertices);
-		}
-		let verts=mesh.unique_pos.iter().copied().map(Vert).collect();
-		//TODO: fix submeshes
-		//flat map mesh.physics_groups[$1].groups.polys()[$2] as face_id
-		//lower face_id points to upper face_id
-		//the same face is not allowed to be in multiple polygon groups
-		let mut faces=Vec::new();
-		let mut face_id_from_face=HashMap::new();
-		let mut mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
-			//construct submesh
-			let mut submesh_faces=Vec::new();//these contain a map from submeshId->meshId
-			let mut submesh_verts=Vec::new();
-			let mut submesh_vert_id_from_mesh_vert_id=HashMap::<MeshVertId,SubmeshVertId>::new();
-			//lazy closure
-			let mut get_submesh_vert_id=|vert_id:MeshVertId|{
-				if let Some(&submesh_vert_id)=submesh_vert_id_from_mesh_vert_id.get(&vert_id){
-					submesh_vert_id
-				}else{
-					let submesh_vert_id=SubmeshVertId::new(submesh_verts.len() as u32);
-					submesh_verts.push(vert_id);
-					submesh_vert_id_from_mesh_vert_id.insert(vert_id,submesh_vert_id);
-					submesh_vert_id
-				}
-			};
 		let mut edge_pool=EdgePool::default();
-			let mut vert_ref_guys=vec![VertRefGuy::default();mesh.unique_pos.len()];
+		let mut face_i=0;
+		let mut faces=Vec::new();
 		let mut face_ref_guys=Vec::new();
-			for polygon_group_id in &physics_group.groups{
+		for group in indexed_model.groups.iter(){for poly in group.polys.iter(){
-				let polygon_group=&mesh.polygon_groups[polygon_group_id.get() as usize];
+			let face_id=FaceId(face_i);
-				for poly_vertices in polygon_group.polys(){
-					let submesh_face_id=SubmeshFaceId::new(submesh_faces.len() as u32);
 			//one face per poly
-					let mut normal=Vector3::new([Fixed::ZERO,Fixed::ZERO,Fixed::ZERO]);
+			let mut normal=Planar64Vec3::ZERO;
-					let len=poly_vertices.len();
+			let len=poly.vertices.len();
-					let face_edges=poly_vertices.into_iter().enumerate().map(|(i,vert_id)|{
+			let face_edges=poly.vertices.iter().enumerate().map(|(i,&vert_id)|{
-						let vert0_id=MeshVertId::new(mesh.unique_vertices[vert_id.get() as usize].pos.get() as u32);
+				let vert0_id=indexed_model.unique_vertices[vert_id as usize].pos as usize;
-						let vert1_id=MeshVertId::new(mesh.unique_vertices[poly_vertices[(i+1)%len].get() as usize].pos.get() as u32);
+				let vert1_id=indexed_model.unique_vertices[poly.vertices[(i+1)%len] as usize].pos as usize;
-						//index submesh verts
-						let submesh_vert0_id=get_submesh_vert_id(vert0_id);
-						let submesh_vert1_id=get_submesh_vert_id(vert1_id);
 				//https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal (Newell's Method)
-						let v0=mesh.unique_pos[vert0_id.get() as usize];
+				let v0=indexed_model.unique_pos[vert0_id];
-						let v1=mesh.unique_pos[vert1_id.get() as usize];
+				let v1=indexed_model.unique_pos[vert1_id];
-						normal+=Vector3::new([
+				normal+=Planar64Vec3::new(
-							(v0.y-v1.y)*(v0.z+v1.z),
+					(v0.y()-v1.y())*(v0.z()+v1.z()),
-							(v0.z-v1.z)*(v0.x+v1.x),
+					(v0.z()-v1.z())*(v0.x()+v1.x()),
-							(v0.x-v1.x)*(v0.y+v1.y),
+					(v0.x()-v1.x())*(v0.y()+v1.y()),
-						]);
+				);
 				//get/create edge and push face into it
-						let (edge_ref_verts,is_sorted)=EdgeRefVerts::new(submesh_vert0_id,submesh_vert1_id);
+				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,submesh_face_id);
+				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(submesh_vert0_id.get() as usize)};
+					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(submesh_face_id);
+					vert_ref_guy.faces.insert(face_id);
-							unsafe{vert_ref_guys.get_unchecked_mut(submesh_vert1_id.get() as usize)}.edges.insert(edge_id.as_directed(!is_sorted));
+					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();
-					let mut dot=Fixed::ZERO;
+			//choose precision loss randomly idk
-					// find the average dot
+			normal=normal/len as i64;
-					for &v in poly_vertices{
+			let mut dot=Planar64::ZERO;
-						dot+=normal.dot(mesh.unique_pos[mesh.unique_vertices[v.get() as usize].pos.get() as usize]);
+			for &v in poly.vertices.iter(){
+				dot+=normal.dot(indexed_model.unique_pos[indexed_model.unique_vertices[v as usize].pos as usize]);
 			}
-					//assume face hash is stable, and there are no flush faces...
+			faces.push(Face{normal,dot:dot/len as i64});
-					let face=Face{
-						normal:(normal/len as i64).divide().fix_1(),
-						dot:(dot/(len*len) as i64).fix_1(),
-					};
-					let face_id=match face_id_from_face.get(&face){
-						Some(&face_id)=>face_id,
-						None=>{
-							let face_id=MeshFaceId::new(faces.len() as u32);
-							face_id_from_face.insert(face.clone(),face_id);
-							faces.push(face);
-							face_id
-						}
-					};
-					submesh_faces.push(face_id);
 			face_ref_guys.push(FaceRefEdges(face_edges));
-				}
+			face_i+=1;
-			}
+		}}
-			PhysicsMeshTopology{
+		//conceivably faces, edges, and vertices exist now
-				faces:submesh_faces,
+		Self{
-				verts:submesh_verts,
+			faces,
+			verts,
 			face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
 				FaceRefs{edges:face_ref_guy.0}
 			}).collect(),
@@ -405,127 +201,102 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 				}
 			).collect(),
 		}
-		}).collect();
-		Ok(Self{
-			data:PhysicsMeshData{
-				faces,
-				verts,
-			},
-			complete_mesh:mesh_topologies.pop().ok_or(PhysicsMeshError::NoPhysicsGroups)?,
-			submeshes:mesh_topologies,
-		})
 	}
 }
 
-pub struct PhysicsMeshView<'a>{
+impl PhysicsMesh{
-	data:&'a PhysicsMeshData,
+	pub fn verts<'a>(&'a self)->impl Iterator<Item=Planar64Vec3>+'a{
-	topology:&'a PhysicsMeshTopology,
+		self.verts.iter().map(|Vert(pos)|*pos)
 	}
-impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMeshView<'_>{
+}
-	type Normal=Planar64Vec3;
+impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
-	type Offset=Planar64;
+	fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
-	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
+		(self.faces[face_id.0].normal,self.faces[face_id.0].dot)
-		let face_idx=self.topology.faces[face_id.get() as usize].get() as usize;
-		(self.data.faces[face_idx].normal,self.data.faces[face_idx].dot)
 	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
-	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
+	fn vert(&self,vert_id:VertId)->Planar64Vec3{
-		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
+		self.verts[vert_id.0].0
-		self.data.verts[vert_idx].0
 	}
-	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<Vec<SubmeshDirectedEdgeId>>{
+	fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
-		Cow::Borrowed(&self.topology.face_topology[face_id.get() as usize].edges)
+		Cow::Borrowed(&self.face_topology[face_id.0].edges)
 	}
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshFaceId;2]>{
+	fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
-		Cow::Borrowed(&self.topology.edge_topology[edge_id.get() as usize].faces)
+		Cow::Borrowed(&self.edge_topology[edge_id.0].faces)
 	}
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
-		Cow::Borrowed(&self.topology.edge_topology[edge_id.get() as usize].verts)
+		Cow::Borrowed(&self.edge_topology[edge_id.0].verts)
 	}
-	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshDirectedEdgeId>>{
+	fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
-		Cow::Borrowed(&self.topology.vert_topology[vert_id.get() as usize].edges)
+		Cow::Borrowed(&self.vert_topology[vert_id.0].edges)
-	}
-	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshFaceId>>{
-		Cow::Borrowed(&self.topology.vert_topology[vert_id.get() as usize].faces)
-	}
-}
-
-pub struct PhysicsMeshTransform{
-	pub vertex:integer::Planar64Affine3,
-	pub normal:integer::mat3::Matrix3<Fixed<2,64>>,
-	pub det:Fixed<3,96>,
-}
-impl PhysicsMeshTransform{
-	pub fn new(transform:integer::Planar64Affine3)->Self{
-		Self{
-			normal:transform.matrix3.adjugate().transpose(),
-			det:transform.matrix3.det(),
-			vertex:transform,
 	}
+	fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
+		Cow::Borrowed(&self.vert_topology[vert_id.0].faces)
 	}
 }
 
 pub struct TransformedMesh<'a>{
-	view:PhysicsMeshView<'a>,
+	mesh:&'a PhysicsMesh,
-	transform:&'a PhysicsMeshTransform,
+	transform:&'a crate::integer::Planar64Affine3,
+	normal_transform:&'a crate::integer::Planar64Mat3,
+	transform_det:Planar64,
 }
 impl TransformedMesh<'_>{
-	pub const fn new<'a>(
+	pub fn new<'a>(
-		view:PhysicsMeshView<'a>,
+		mesh:&'a PhysicsMesh,
-		transform:&'a PhysicsMeshTransform,
+		transform:&'a crate::integer::Planar64Affine3,
+		normal_transform:&'a crate::integer::Planar64Mat3,
+		transform_det:Planar64,
 		)->TransformedMesh<'a>{
 		TransformedMesh{
-			view,
+			mesh,
 			transform,
+			normal_transform,
+			transform_det,
 		}
 	}
-	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
+	fn farthest_vert(&self,dir:Planar64Vec3)->VertId{
-		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
+		let mut best_dot=Planar64::MIN;
-	}
+		let mut best_vert=VertId(0);
-	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		for (i,vert) in self.mesh.verts.iter().enumerate(){
-		//this happens to be well-defined.  there are no virtual virtices
+			let p=self.transform.transform_point3(vert.0);
-		SubmeshVertId::new(
+			let d=dir.dot(p);
-			self.view.topology.verts.iter()
+			if best_dot<d{
-			.enumerate()
+				best_dot=d;
-			.max_by_key(|(_,&vert_id)|
+				best_vert=VertId(i);
-				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
-			)
-			//assume there is more than zero vertices.
-			.unwrap().0 as u32
-		)
 			}
 		}
-impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for TransformedMesh<'_>{
+		best_vert
-	type Normal=Vector3<Fixed<3,96>>;
-	type Offset=Fixed<4,128>;
-	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
-		let (n,d)=self.view.face_nd(face_id);
-		let transformed_n=self.transform.normal*n;
-		let transformed_d=d*self.transform.det+transformed_n.dot(self.transform.vertex.translation);
-		(transformed_n,transformed_d)
 	}
-	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
+}
-		self.transform.vertex.transform_point3(self.view.vert(vert_id)).fix_1()
+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:SubmeshFaceId)->Cow<Vec<SubmeshDirectedEdgeId>>{
+	fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
-		self.view.face_edges(face_id)
+		self.mesh.face_edges(face_id)
 	}
 	#[inline]
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshFaceId;2]>{
+	fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
-		self.view.edge_faces(edge_id)
+		self.mesh.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
-		self.view.edge_verts(edge_id)
+		self.mesh.edge_verts(edge_id)
 	}
 	#[inline]
-	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshDirectedEdgeId>>{
+	fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
-		self.view.vert_edges(vert_id)
+		self.mesh.vert_edges(vert_id)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<Vec<SubmeshFaceId>>{
+	fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
-		self.view.vert_faces(vert_id)
+		self.mesh.vert_faces(vert_id)
 	}
 }
 
@@ -533,14 +304,14 @@ impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for Transforme
 //(face,vertex)
 //(edge,edge)
 //(vertex,face)
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy)]
 pub enum MinkowskiVert{
-	VertVert(SubmeshVertId,SubmeshVertId),
+	VertVert(VertId,VertId),
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy)]
 pub enum MinkowskiEdge{
-	VertEdge(SubmeshVertId,SubmeshEdgeId),
+	VertEdge(VertId,EdgeId),
-	EdgeVert(SubmeshEdgeId,SubmeshVertId),
+	EdgeVert(EdgeId,VertId),
 	//EdgeEdge when edges are parallel
 }
 impl UndirectedEdge for MinkowskiEdge{
@@ -552,10 +323,10 @@ impl UndirectedEdge for MinkowskiEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy)]
 pub enum MinkowskiDirectedEdge{
-	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
+	VertEdge(VertId,DirectedEdgeId),
-	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
+	EdgeVert(DirectedEdgeId,VertId),
 	//EdgeEdge when edges are parallel
 }
 impl DirectedEdge for MinkowskiDirectedEdge{
@@ -573,23 +344,22 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
 pub enum MinkowskiFace{
-	VertFace(SubmeshVertId,SubmeshFaceId),
+	VertFace(VertId,FaceId),
-	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
+	EdgeEdge(EdgeId,EdgeId,bool),
-	FaceVert(SubmeshFaceId,SubmeshVertId),
+	FaceVert(FaceId,VertId),
 	//EdgeFace
 	//FaceEdge
 	//FaceFace
 }
 
 pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
+	mesh0:&'a TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
+	mesh1:&'a TransformedMesh<'a>,
 }
 
 //infinity fev algorithm state transition
-#[derive(Debug)]
 enum Transition{
 	Done,//found closest vert, no edges are better
 	Vert(MinkowskiVert),//transition to vert
@@ -599,10 +369,8 @@ enum EV{
 	Edge(MinkowskiEdge),
 }
 
-pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
-
 impl MinkowskiMesh<'_>{
-	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
+	pub fn minkowski_sum<'a>(mesh0:&'a TransformedMesh,mesh1:&'a TransformedMesh)->MinkowskiMesh<'a>{
 		MinkowskiMesh{
 			mesh0,
 			mesh1,
@@ -611,7 +379,7 @@ impl MinkowskiMesh<'_>{
 	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 Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
+	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);
@@ -621,7 +389,7 @@ impl MinkowskiMesh<'_>{
 			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 edge_n.dot(infinity_dir).is_zero(){
+			if crate::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);
@@ -631,21 +399,21 @@ impl MinkowskiMesh<'_>{
 		}
 		best_transition
 	}
-	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
+	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
-			if edge_n.dot(infinity_dir).is_zero(){
 			let d=edge_n.dot(diff);
+			if crate::zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
 				//test the edge
 				let edge_nn=edge_n.dot(edge_n);
-				if !d.is_negative()&&d<=edge_nn{
+				if Planar64::ZERO<=d&&d<=edge_nn{
 					let distance_squared={
 						let c=diff.cross(edge_n);
-						(c.dot(c)/edge_nn).divide().fix_2()
+						c.dot(c)/edge_nn
 					};
 					if distance_squared<=*best_distance_squared{
 						best_transition=EV::Edge(directed_edge_id.as_undirected());
@@ -691,7 +459,7 @@ impl MinkowskiMesh<'_>{
 					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.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
+					if (boundary_d)<=Planar64::ZERO&&crate::zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
 						//both faces cannot pass this condition, return early if one does.
 						return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
 					}
@@ -705,16 +473,15 @@ impl MinkowskiMesh<'_>{
 			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=vec3::ZERO;
+			infinity_body.acceleration=Planar64Vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			// TODO: change crawl_fev args to delta time? Optional values?
+			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,crate::integer::Time::MIN,infinity_body.time){
-			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,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,GigaTime)>{
+	pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
 		self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
 			//continue forwards along the body parabola
 			match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
@@ -723,7 +490,7 @@ impl MinkowskiMesh<'_>{
 			}
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time)->Option<(MinkowskiFace,crate::integer::Time)>{
 		//create an extrapolated body at time_limit
 		let infinity_body=crate::physics::Body::new(
 			relative_body.extrapolated_position(time_limit),
@@ -739,13 +506,10 @@ impl MinkowskiMesh<'_>{
 			}
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:crate::integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,crate::integer::Time)>{
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
-		let mut best_time={
+		let mut best_time=time_limit;
-			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
-		};
 		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(){
@@ -755,10 +519,10 @@ impl MinkowskiMesh<'_>{
 			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
-			//WARNING: truncated precision
+			for t in crate::zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
-			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).fix_4(),n.dot(relative_body.velocity).fix_4()*2,n.dot(relative_body.acceleration).fix_4()){
+				let t=relative_body.time+crate::integer::Time::from(t);
-				if Ratio::new(Planar64::ZERO,Planar64::EPSILON).le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
-					best_time=dt;
+					best_time=t;
 					best_edge=Some(directed_edge_id);
 					break;
 				}
@@ -766,28 +530,9 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge.map(|e|(e.as_undirected(),best_time))
 	}
-	fn infinity_in(&self,infinity_body:crate::physics::Body)->Option<(MinkowskiFace,GigaTime)>{
-		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
-			crate::face_crawler::CrawlResult::Miss(_)=>None,
-			crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
-		}
-	}
-	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
-		let infinity_body=crate::physics::Body::new(point,vec3::Y,vec3::ZERO,integer::Time::ZERO);
-		//movement must escape the mesh forwards and backwards in time,
-		//otherwise the point is not inside the mesh
-		self.infinity_in(infinity_body)
-    	.is_some_and(|_|
-			self.infinity_in(-infinity_body)
-    		.is_some()
-     	)
-	}
 }
 impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
-	type Normal=Vector3<Fixed<3,96>>;
+	fn face_nd(&self,face_id:MinkowskiFace)->(Planar64Vec3,Planar64){
-	type Offset=Fixed<4,128>;
-	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
 				let (n,d)=self.mesh1.face_nd(f1);
@@ -801,7 +546,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 				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)).fix_3(),((e0d-e1d)*(parity as i64*2-1)).fix_4())
+				(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);
@@ -850,18 +595,17 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 				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:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					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.is_negative(){
+						if d<Planar64::ZERO{
 							let edge0_nn=edge0_n.dot(edge0_n);
-							// Assume not every number is huge
+							//divide by zero???
-							// TODO: revisit this
+							let dd=d*d/(edge_face1_nn*edge0_nn);
-							let dd=(d*d)/(edge_face1_nn*edge0_nn);
 							if best_d<dd{
 								best_d=dd;
 								best_edge=Some(directed_edge_id0);
@@ -880,15 +624,15 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 				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:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					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.is_negative(){
+						if d<Planar64::ZERO{
 							let edge1_nn=edge1_n.dot(edge1_n);
-							let dd=(d*d)/(edge_face0_nn*edge1_nn);
+							let dd=d*d/(edge_face0_nn*edge1_nn);
 							if best_d<dd{
 								best_d=dd;
 								best_edge=Some(directed_edge_id1);
@@ -924,20 +668,19 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 				//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<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v0f_n:Vec<Planar64Vec3>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.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);
-					// TODO: there's gotta be a better way to do this
 					//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).divide().fix_3());
+						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));
@@ -949,7 +692,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 					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).divide().fix_3());
+						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));
@@ -964,7 +707,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 	}
 }
 
-fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
+fn is_empty_volume(normals:Vec<Planar64Vec3>)->bool{
 	let len=normals.len();
 	for i in 0..len-1{
 		for j in i+1..len{
@@ -972,10 +715,9 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 			let mut d_comp=None;
 			for k in 0..len{
 				if k!=i&&k!=j{
-					let d=n.dot(normals[k]).is_negative();
+					let d=n.dot(normals[k]);
 					if let Some(comp)=&d_comp{
-						// This is testing if d_comp*d < 0
+						if *comp*d<Planar64::ZERO{
-						if comp^d{
 							return true;
 						}
 					}else{
@@ -990,12 +732,13 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 
 #[test]
 fn test_is_empty_volume(){
-	assert!(!is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3()].to_vec()));
+	assert!(!is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z].to_vec()));
-	assert!(is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3(),vec3::NEG_X.fix_3()].to_vec()));
+	assert!(is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z,Planar64Vec3::NEG_X].to_vec()));
 }
 
 #[test]
 fn build_me_a_cube(){
-	let mesh=PhysicsMesh::unit_cube();
+	let unit_cube=crate::primitives::unit_cube();
+	let mesh=PhysicsMesh::from(&unit_cube);
 	//println!("mesh={:?}",mesh);
 }

src/physics_worker.rs

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

src/primitives.rs

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

src/settings.rs

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

src/setup.rs

@@ -1,6 +1,5 @@
+use crate::instruction::TimedInstruction;
 use crate::window::WindowInstruction;
-use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::integer;
 
 fn optional_features()->wgpu::Features{
 	wgpu::Features::TEXTURE_COMPRESSION_ASTC
@@ -25,14 +24,14 @@ struct SetupContextPartial1{
 	instance:wgpu::Instance,
 }
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
-	let mut attr=winit::window::WindowAttributes::default();
+	let mut builder = winit::window::WindowBuilder::new();
-	attr=attr.with_title(title);
+	builder = builder.with_title(title);
 	#[cfg(windows_OFF)] // TODO
 	{
 		use winit::platform::windows::WindowBuilderExtWindows;
 		builder = builder.with_no_redirection_bitmap(true);
 	}
-	event_loop.create_window(attr)
+	builder.build(event_loop)
 }
 fn create_instance()->SetupContextPartial1{
 	let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
@@ -143,7 +142,6 @@ impl<'a> SetupContextPartial3<'a>{
 					label: None,
 					required_features: (optional_features & self.adapter.features()) | required_features,
 					required_limits: needed_limits,
-					memory_hints:wgpu::MemoryHints::Performance,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
@@ -213,19 +211,9 @@ pub fn setup_and_start(title:String){
 
 	//dedicated thread to ping request redraw back and resize the window doesn't seem logical
 
+	let window=crate::window::WindowContextSetup::new(&setup_context,&window);
 	//the thread that spawns the physics thread
-	let mut window_thread=crate::window::worker(
+	let window_thread=window.into_worker(setup_context);
-		&window,
-		setup_context,
-	);
-
-	if let Some(arg)=std::env::args().nth(1){
-		let path=std::path::PathBuf::from(arg);
-		window_thread.send(TimedInstruction{
-			time:integer::Time::ZERO,
-			instruction:WindowInstruction::WindowEvent(winit::event::WindowEvent::DroppedFile(path)),
-		}).unwrap();
-	};
 
 	println!("Entering event loop...");
 	let root_time=std::time::Instant::now();
@@ -238,7 +226,7 @@ fn run_event_loop(
 	root_time:std::time::Instant
 	)->Result<(),winit::error::EventLoopError>{
 		event_loop.run(move |event,elwt|{
-			let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
+			let time=crate::integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
 			// *control_flow=if cfg!(feature="metal-auto-capture"){
 			// 	winit::event_loop::ControlFlow::Exit
 			// }else{

src/shader.wgsl

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

src/window.rs

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

src/worker.rs

@@ -173,24 +173,19 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 	}
 }
 
-#[cfg(test)]
-mod test{
-	use super::{thread,QRWorker};
-	use crate::physics;
-	use strafesnet_common::{integer,instruction};
 #[test]//How to run this test with printing: cargo test --release -- --nocapture
 fn test_worker() {
 	// Create the worker thread
-		let test_body=physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO);
+	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(physics::Body::ZERO,
+	let worker=QRWorker::new(crate::physics::Body::default(),
-			|_|physics::Body::new(integer::vec3::ONE,integer::vec3::ONE,integer::vec3::ONE,integer::Time::ZERO)
+		|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
 	);
 
 	// Send tasks to the worker
 	for _ in 0..5 {
-			let task = instruction::TimedInstruction{
+		let task = crate::instruction::TimedInstruction{
-				time:integer::Time::ZERO,
+			time:crate::integer::Time::ZERO,
-				instruction:strafesnet_common::physics::Instruction::Idle,
+			instruction:crate::physics::PhysicsInstruction::StrafeTick,
 		};
 		worker.send(task).unwrap();
 	}
@@ -202,9 +197,9 @@ mod test{
 	thread::sleep(std::time::Duration::from_millis(10));
 
 	// Send a new task
-		let task = instruction::TimedInstruction{
+	let task = crate::instruction::TimedInstruction{
-			time:integer::Time::ZERO,
+		time:crate::integer::Time::ZERO,
-			instruction:strafesnet_common::physics::Instruction::Idle,
+		instruction:crate::physics::PhysicsInstruction::StrafeTick,
 	};
 	worker.send(task).unwrap();
 
@@ -213,4 +208,3 @@ mod test{
 	// wait long enough to see print from final task
 	thread::sleep(std::time::Duration::from_millis(10));
 }
-}

src/zeroes.rs

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

tools/arcane

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

tools/bhop_maps

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

tools/cross-compile.sh

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

tools/iso

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

tools/surf_maps

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

tools/textures

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

tools/toc

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

tools/utopia

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