fix big wrong

Cargo.toml

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

LICENSE

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

src/aabb.rs

@@ -0,0 +1,43 @@
+use crate::integer::Planar64Vec3;
+
+#[derive(Clone)]
+pub struct Aabb{
+	pub min:Planar64Vec3,
+	pub max:Planar64Vec3,
+}
+
+impl Default for Aabb {
+	fn default()->Self {
+		Self{min:Planar64Vec3::MAX,max:Planar64Vec3::MIN}
+	}
+}
+
+impl Aabb{
+	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 center(&self)->Planar64Vec3{
+		return self.min.midpoint(self.max)
+	}
+	//probably use floats for area & volume because we don't care about precision
+	// pub fn area_weight(&self)->f32{
+	// 	let d=self.max-self.min;
+	// 	d.x*d.y+d.y*d.z+d.z*d.x
+	// }
+	// pub fn volume(&self)->f32{
+	// 	let d=self.max-self.min;
+	// 	d.x*d.y*d.z
+	// }
+}

src/bvh.rs

@@ -0,0 +1,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.partial_cmp(&tup1.1).unwrap());
+		sort_y.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
+		sort_z.sort_by(|tup0,tup1|tup0.1.partial_cmp(&tup1.1).unwrap());
+		let h=n/2;
+		let median_x=sort_x[h].1;
+		let median_y=sort_y[h].1;
+		let median_z=sort_z[h].1;
+		for (i,c) in sort_x{
+			if median_x<c{
+				octant.insert(i,octant[&i]+1<<0);
+			}
+		}
+		for (i,c) in sort_y{
+			if median_y<c{
+				octant.insert(i,octant[&i]+1<<1);
+			}
+		}
+		for (i,c) in sort_z{
+			if median_z<c{
+				octant.insert(i,octant[&i]+1<<2);
+			}
+		}
+		//generate lists for unique octant values
+		let mut list_list=Vec::with_capacity(8);
+		let mut octant_list=Vec::with_capacity(8);
+		for (i,aabb) in boxen.into_iter(){
+			let octant_id=octant[&i];
+			let list_id=if let Some(list_id)=octant_list.iter().position(|&id|id==octant_id){
+				list_id
+			}else{
+				let list_id=list_list.len();
+				octant_list.push(octant_id);
+				list_list.push(Vec::new());
+				list_id
+			};
+			list_list[list_id].push((i,aabb));
+		}
+		let mut aabb=Aabb::default();
+		let children=list_list.into_iter().map(|b|{
+			let node=generate_bvh_node(b);
+			aabb.join(&node.aabb);
+			node
+		}).collect();
+		BvhNode{
+			content:BvhNodeContent::Branch(children),
+			aabb,
+		}
+	}
+}

src/face_crawler.rs

@@ -1,46 +1,49 @@
 use crate::physics::Body;
-use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
+use crate::model_physics::{FEV,MeshQuery};
-use strafesnet_common::integer::{Time,Planar64};
+use crate::integer::{Time,Planar64,Planar64Vec3};
-use strafesnet_common::zeroes::zeroes2;
+use crate::zeroes::zeroes2;
 
-enum Transition<F,E:DirectedEdge,V>{
+struct State<FEV>{
+	fev:FEV,
+	time:Time,
+}
+
+enum Transition<F,E,V>{
 	Miss,
 	Next(FEV<F,E,V>,Time),
 	Hit(F,Time),
 }
 
-	fn next_transition<F:Copy,E:Copy+DirectedEdge,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
+impl<F:Copy,E:Copy,V:Copy> State<FEV<F,E,V>>{
+	fn next_transition(&self,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_time=time_limit;
 		let mut best_transtition=Transition::Miss;
-		match fev{
+		match &self.fev{
 			&FEV::<F,E,V>::Face(face_id)=>{
 				//test own face collision time, ignoring roots with zero or conflicting derivative
 				//n=face.normal d=face.dot
 				//n.a t^2+n.v t+n.p-d==0
 				let (n,d)=mesh.face_nd(face_id);
-				//TODO: use higher precision d value?
-				//use the mesh transform translation instead of baking it into the d value.
 				for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 					let t=body.time+Time::from(t);
-					if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+					if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 						best_time=t;
 						best_transtition=Transition::Hit(face_id,t);
-						break;
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).iter(){
+				for &(edge_id,test_face_id) in mesh.face_edges(face_id).iter(){
-					let edge_n=mesh.directed_edge_n(directed_edge_id);
+					let edge_n=mesh.edge_n(edge_id);
 					let n=n.cross(edge_n);
-					let verts=mesh.edge_verts(directed_edge_id.as_undirected());
+					//picking a vert randomly is terrible
-					//WARNING: d is moved out of the *2 block because of adding two vertices!
+					let d=n.dot(mesh.vert(mesh.edge_verts(edge_id)[0]));
-					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 t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
+							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(edge_id),t);
 							break;
 						}
 					}
@@ -50,29 +53,26 @@ enum Transition<F,E:DirectedEdge,V>{
 			&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);
+				for &test_face_id in mesh.edge_faces(edge_id).iter(){
-				let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
+					let face_n=mesh.face_nd(test_face_id).0;
-				for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
+					let n=edge_n.cross(face_n);
-					let face_n=mesh.face_nd(edge_face_id).0;
+					let d=n.dot(mesh.vert(mesh.edge_verts(edge_id)[0]));
-					//edge_n gets parity from the order of edge_faces
+					for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					let n=face_n.cross(edge_n)*((i as i64)*2-1);
-					//WARNING yada yada d *2
-					for t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
+							best_transtition=Transition::Next(FEV::<F,E,V>::Face(test_face_id),t);
 							break;
 						}
 					}
 				}
 				//test each vertex collision time, ignoring roots with zero or conflicting derivative
-				for (i,&vert_id) in edge_verts.iter().enumerate(){
+				let n=mesh.edge_n(edge_id);
-					//vertex normal gets parity from vert index
+				for &vert_id in mesh.edge_verts(edge_id).iter(){
-					let n=edge_n*(1-2*(i as i64));
+					let d=n.dot(mesh.vert(vert_id));
-					for t in 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)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
 							best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
 							break;
@@ -83,14 +83,14 @@ enum Transition<F,E:DirectedEdge,V>{
 			},
 			&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(){
+				for &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.edge_n(edge_id);
-					let n=-mesh.directed_edge_n(directed_edge_id);
+					let d=n.dot(mesh.vert(vert_id));
-					for t in 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)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						let t=body.time+Time::from(t);
-						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						if self.time<t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
 							best_time=t;
-							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
+							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(edge_id),t);
 							break;
 						}
 					}
@@ -100,20 +100,27 @@ enum Transition<F,E:DirectedEdge,V>{
 		}
 		best_transtition
 	}
-pub enum CrawlResult<F,E:DirectedEdge,V>{
-	Miss(FEV<F,E,V>),
-	Hit(F,Time),
 }
-pub fn crawl_fev<F:Copy,E:Copy+DirectedEdge,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>{	
+
-	let mut time=start_time;
+pub fn predict_collision<F:Copy,E:Copy,V:Copy>(mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time)->Option<(F,Time)>{
-	for _ in 0..20{
+	let mut state=State{
-		match next_transition(&fev,time,mesh,relative_body,time_limit){
+		fev:mesh.closest_fev(relative_body.position),
-			Transition::Miss=>return CrawlResult::Miss(fev),
+		time:relative_body.time,
-			Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
+	};
-			Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
+	//it would be possible to write down the point of closest approach...
+	loop{
+		match state.next_transition(mesh,relative_body,time_limit){
+			Transition::Miss=>return None,
+			Transition::Next(fev,time)=>(state.fev,state.time)=(fev,time),
+			Transition::Hit(face,time)=>return Some((face,time)),
 		}
 	}
-	//TODO: fix all bugs
+}
-	println!("Too many iterations!  Using default behaviour instead of crashing...");
+
-	CrawlResult::Miss(fev)
+pub fn predict_collision_end<F:Copy,E:Copy,V:Copy>(mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,time_limit:Time,ignore_face_id:F)->Option<(F,Time)>{
+	//imagine the mesh without the collision face
+	//no algorithm needed, there is only one state and three cases (Face,Edge,None)
+	//determine when it passes an edge ("sliding off" case) or if it leaves the surface directly
+	//the state can be constructed from the ContactCollision directly
+	None
 }

src/graphics.rs

@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use strafesnet_common::integer;
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
 use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
 
@@ -153,14 +152,11 @@ impl GraphicsState{
 		let mut texture_loading_threads=Vec::new();
 		let num_textures=indexed_models.textures.len();
 		for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
-			let path=std::path::PathBuf::from(format!("textures/{}.dds",texture_id));
+			if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&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);
 			}
 		}
 
@@ -204,7 +200,6 @@ impl GraphicsState{
 					label: Some(format!("Texture{}",texture_id).as_str()),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&image.data,
 			);
 			texture.create_view(&wgpu::TextureViewDescriptor {
@@ -221,7 +216,7 @@ impl GraphicsState{
 		for model in indexed_models.models.into_iter(){
 			//convert ModelInstance into GraphicsModelInstance
 			let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
-				if instance.color.w==0.0&&!model.groups.iter().any(|g|g.texture.is_some()){
+				if instance.color.w==0.0{
 					None
 				}else{
 					Some(GraphicsModelInstance{
@@ -702,7 +697,6 @@ impl GraphicsState{
 					label: Some("Skybox Texture"),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&skybox_image.data,
 			);
 
@@ -743,7 +737,6 @@ impl GraphicsState{
 					label: Some("Squid Texture"),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&image.data,
 			);
 
@@ -834,7 +827,7 @@ impl GraphicsState{
 		});
 
 		let camera=GraphicsCamera::default();
-		let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,integer::Time::ZERO));
+		let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,crate::integer::Time::ZERO));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
 			contents: bytemuck::cast_slice(&camera_uniforms),
@@ -903,7 +896,7 @@ impl GraphicsState{
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
 		physics_output:crate::physics::PhysicsOutputState,
-		predicted_time:integer::Time,
+		predicted_time:crate::integer::Time,
 		mouse_pos:glam::IVec2,
 	) {
 		//TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input

src/graphics_worker.rs

@@ -1,7 +1,5 @@
-use strafesnet_common::integer;
-
 pub enum Instruction{
-	Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2),
+	Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
 	//UpdateModel(crate::graphics::GraphicsModelUpdate),
 	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
 	GenerateModels(crate::model::IndexedModelInstances),
@@ -20,7 +18,7 @@ WorkerDescription{
 pub fn new<'a>(
 		mut graphics:crate::graphics::GraphicsState,
 		mut config:wgpu::SurfaceConfiguration,
-		surface:wgpu::Surface<'a>,
+		surface:wgpu::Surface,
 		device:wgpu::Device,
 		queue:wgpu::Queue,
 	)->crate::compat_worker::INWorker<'a,Instruction>{

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

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

src/load_roblox.rs

@@ -1,5 +1,5 @@
 use crate::primitives;
-use strafesnet_common::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
+use crate::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
 
 fn class_is_a(class: &str, superclass: &str) -> bool {
 	if class==superclass {
@@ -14,15 +14,12 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
 	return false
 }
 fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
-	let mut stack=vec![instance];
+	for &referent in instance.children() {
-	while let Some(item)=stack.pop(){
+		if let Some(c) = dom.get_by_ref(referent) {
-		for &referent in item.children(){
+			if class_is_a(c.class.as_str(), superclass) {
-			if let Some(c)=dom.get_by_ref(referent){
+				objects.push(c.referent());//copy ref
-				if class_is_a(c.class.as_str(),superclass){
-					objects.push(c.referent());//copy ref
-				}
-				stack.push(c);
 			}
+			recursive_collect_superclass(objects,dom,c,superclass);
 		}
 	}
 }
@@ -265,18 +262,6 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 			{
 				let model_transform=planar64_affine3_from_roblox(cf,size);
 
-				if model_transform.matrix3.determinant()==Planar64::ZERO{
-					let mut parent_ref=object.parent();
-					let mut full_path=object.name.clone();
-					while let Some(parent)=dom.get_by_ref(parent_ref){
-						full_path=format!("{}.{}",parent.name,full_path);
-						parent_ref=parent.parent();
-					}
-					println!("Zero determinant CFrame at location {}",full_path);
-					println!("matrix3:{}",model_transform.matrix3);
-					continue;
-				}
-
 				//push TempIndexedAttributes
 				let mut force_intersecting=false;
 				let mut temp_indexing_attributes=Vec::new();

src/main.rs

@@ -1,14 +1,16 @@
-use strafesnet_common::integer;
+mod bvh;
-
+mod aabb;
 mod model;
 mod setup;
 mod window;
 mod worker;
+mod zeroes;
+mod integer;
 mod physics;
 mod graphics;
 mod settings;
 mod primitives;
-mod load_bsp;
+mod instruction;
 mod load_roblox;
 mod face_crawler;
 mod compat_worker;
@@ -44,7 +46,7 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
 						},
 					}
 				},
-				b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(),
+				//b"VBSP"=>Some(load_bsp::generate_indexed_models(input)),
 				//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
 				//b"SNFB"=>Some(sniffer::load_bot(input)),
 				other=>{
@@ -114,5 +116,6 @@ pub fn default_models()->model::IndexedModelInstances{
 }
 
 fn main(){
-	setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
+	let context=setup::setup(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str());
+	context.start();//creates and runs a window context
 }

src/model.rs

@@ -1,4 +1,4 @@
-use strafesnet_common::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
+use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
 pub type TextureCoordinate=glam::Vec2;
 pub type Color4=glam::Vec4;
 #[derive(Clone,Hash,PartialEq,Eq)]
@@ -259,6 +259,7 @@ impl IntersectingAttributes{
 	}
 }
 //Spawn(u32) NO! spawns are indexed in the map header instead of marked with attibutes
+//TODO: deduplicate attributes
 pub enum CollisionAttributes{
 	Decoration,//visual only
 	Contact{//track whether you are contacting the object

src/physics.rs

@@ -1,8 +1,6 @@
+use crate::instruction::{InstructionEmitter,InstructionConsumer,TimedInstruction};
+use crate::integer::{Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
 use crate::model_physics::{PhysicsMesh,TransformedMesh,MeshQuery};
-use strafesnet_common::bvh;
-use strafesnet_common::aabb;
-use strafesnet_common::instruction::{self,InstructionEmitter,InstructionConsumer,TimedInstruction};
-use strafesnet_common::integer::{self,Time,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
 
 #[derive(Debug)]
 pub enum PhysicsInstruction {
@@ -45,17 +43,6 @@ pub struct Body{
 	pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
 	pub time:Time,//nanoseconds x xxxxD!
 }
-impl std::ops::Neg for Body{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		Self{
-			position:self.position,
-			velocity:-self.velocity,
-			acceleration:self.acceleration,
-			time:-self.time,
-		}
-	}
-}
 
 //hey dumbass just use a delta
 #[derive(Clone,Debug)]
@@ -188,9 +175,9 @@ impl PhysicsModels{
 		self.attributes.clear();
 		self.model_id_from_wormhole_id.clear();
 	}
-	fn aabb_list(&self)->Vec<aabb::Aabb>{
+	fn aabb_list(&self)->Vec<crate::aabb::Aabb>{
 		self.models.iter().map(|model|{
-			let mut aabb=aabb::Aabb::default();
+			let mut aabb=crate::aabb::Aabb::default();
 			for pos in self.meshes[model.mesh_id].verts(){
 				aabb.grow(model.transform.transform_point3(pos));
 			}
@@ -204,7 +191,6 @@ impl PhysicsModels{
 			&self.meshes[self.models[model_id].mesh_id],
 			&self.models[model_id].transform,
 			&self.models[model_id].normal_transform,
-			self.models[model_id].transform_det,
 		)
 	}
 	fn model(&self,model_id:usize)->&PhysicsModel{
@@ -341,60 +327,6 @@ struct StrafeSettings{
 	tick_rate:Ratio64,
 }
 
-struct Hitbox{
-	halfsize:Planar64Vec3,
-	mesh:PhysicsMesh,
-	transform:integer::Planar64Affine3,
-	normal_transform:Planar64Mat3,
-	transform_det:Planar64,
-}
-impl Hitbox{
-	fn new(mesh:PhysicsMesh,transform:integer::Planar64Affine3)->Self{
-		//calculate extents
-		let mut aabb=aabb::Aabb::default();
-		for vert in mesh.verts(){
-			aabb.grow(transform.transform_point3(vert));
-		}
-		Self{
-			halfsize:aabb.size()/2,
-			mesh,
-			transform,
-			normal_transform:transform.matrix3.inverse_times_det().transpose(),
-			transform_det:transform.matrix3.determinant(),
-		}
-	}
-	fn from_mesh_scale(mesh:PhysicsMesh,scale:Planar64Vec3)->Self{
-		let matrix3=Planar64Mat3::from_diagonal(scale);
-		Self{
-			halfsize:scale,
-			mesh,
-			normal_transform:matrix3.inverse_times_det().transpose(),
-			transform:integer::Planar64Affine3::new(matrix3,Planar64Vec3::ZERO),
-			transform_det:matrix3.determinant(),//scale.x*scale.y*scale.z but whatever
-		}
-	}
-	fn from_mesh_scale_offset(mesh:PhysicsMesh,scale:Planar64Vec3,offset:Planar64Vec3)->Self{
-		let matrix3=Planar64Mat3::from_diagonal(scale);
-		Self{
-			halfsize:scale,
-			mesh,
-			normal_transform:matrix3.inverse_times_det().transpose(),
-			transform:integer::Planar64Affine3::new(matrix3,offset),
-			transform_det:matrix3.determinant(),
-		}
-	}
-	fn roblox()->Self{
-		Self::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cylinder()),Planar64Vec3::int(2,5,2)/2)
-	}
-	fn source()->Self{
-		Self::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cube()),Planar64Vec3::raw(33<<28,73<<28,33<<28)/2)
-	}
-	#[inline]
-	fn transformed_mesh(&self)->TransformedMesh{
-		TransformedMesh::new(&self.mesh,&self.transform,&self.normal_transform,self.transform_det)
-	}
-}
-
 struct StyleModifiers{
 	controls_used:u32,//controls which are allowed to pass into gameplay
 	controls_mask:u32,//controls which are masked from control state (e.g. jump in scroll style)
@@ -414,7 +346,7 @@ struct StyleModifiers{
 	surf_slope:Option<Planar64>,
 	rocket_force:Option<Planar64>,
 	gravity:Planar64Vec3,
-	hitbox:Hitbox,
+	hitbox_halfsize:Planar64Vec3,
 	camera_offset:Planar64Vec3,
 }
 impl std::default::Default for StyleModifiers{
@@ -436,14 +368,14 @@ impl StyleModifiers{
 	const UP_DIR:Planar64Vec3=Planar64Vec3::Y;
 	const FORWARD_DIR:Planar64Vec3=Planar64Vec3::NEG_Z;
 
-	fn neo()->Self{
+	fn new()->Self{
 		Self{
 			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			strafe:Some(StrafeSettings{
 				enable:EnableStrafe::Always,
 				air_accel_limit:None,
-				tick_rate:Ratio64::new(64,Time::ONE_SECOND.nanos() as u64).unwrap(),
+				tick_rate:Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump_impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
 			jump_calculation:JumpCalculation::Energy,
@@ -451,7 +383,7 @@ impl StyleModifiers{
 			static_friction:Planar64::int(2),
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
-			mv:Planar64::int(3),
+			mv:Planar64::int(2),
 			rocket_force:None,
 			walk_speed:Planar64::int(16),
 			walk_accel:Planar64::int(80),
@@ -460,7 +392,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			surf_slope:Some(Planar64::raw(7)/8),
-			hitbox:Hitbox::roblox(),
+			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
 			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
@@ -489,7 +421,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
-			hitbox:Hitbox::roblox(),
+			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
 			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
@@ -517,7 +449,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
-			hitbox:Hitbox::roblox(),
+			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
 			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
@@ -528,7 +460,7 @@ impl StyleModifiers{
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
 			strafe:Some(StrafeSettings{
 				enable:EnableStrafe::Always,
-				air_accel_limit:Some(Planar64::raw(150<<28)*100),
+				air_accel_limit:Some(Planar64::raw(150<<28)*66),
 				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
 			}),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
@@ -546,7 +478,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),//?
 			swim_speed:Planar64::int(12),//?
 			surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
-			hitbox:Hitbox::source(),
+			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
 			camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
 		}
 	}
@@ -574,7 +506,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),//?
 			swim_speed:Planar64::int(12),//?
 			surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
-			hitbox:Hitbox::source(),
+			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
 			camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
 		}
 	}
@@ -598,7 +530,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			surf_slope:Some(Planar64::raw(3787805118)),// normal.y=0.75
-			hitbox:Hitbox::roblox(),
+			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
 			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
@@ -712,10 +644,6 @@ impl StyleModifiers{
 		let camera_mat=camera.simulate_move_rotation(camera.mouse.lerp(&next_mouse,time));
 		camera_mat*self.get_control_dir(controls)
 	}
-	#[inline]
-	fn mesh(&self)->TransformedMesh{
-		self.hitbox.transformed_mesh()
-	}
 }
 
 enum MoveState{
@@ -727,7 +655,7 @@ enum MoveState{
 
 pub struct PhysicsState{
 	time:Time,
-	pub body:Body,
+	body:Body,
 	world:WorldState,//currently there is only one state the world can be in
 	game:GameMechanicsState,
 	style:StyleModifiers,
@@ -738,14 +666,12 @@ pub struct PhysicsState{
 	controls:u32,
 	move_state:MoveState,
 	models:PhysicsModels,
-	bvh:bvh::BvhNode,
+	bvh:crate::bvh::BvhNode,
 	
 	modes:Modes,
 	//the spawn point is where you spawn when you load into the map.
 	//This is not the same as Reset which teleports you to Spawn0
 	spawn_point:Planar64Vec3,
-	//lmao lets go
-	start_time:Option<Time>,
 }
 #[derive(Clone,Default)]
 pub struct PhysicsOutputState{
@@ -787,26 +713,26 @@ pub struct PhysicsModel{
 	//in this iteration, all it needs is extents.
 	mesh_id:usize,
 	attr_id:usize,
-	transform:integer::Planar64Affine3,
+	transform:crate::integer::Planar64Affine3,
-	normal_transform:integer::Planar64Mat3,
+	normal_transform:crate::integer::Planar64Mat3,
-	transform_det:Planar64,
 }
 
 impl PhysicsModel{
-	pub fn new(mesh_id:usize,attr_id:usize,transform:integer::Planar64Affine3)->Self{
+	pub fn new(mesh_id:usize,attr_id:usize,transform:crate::integer::Planar64Affine3)->Self{
+		let normal_transform=transform.matrix3.inverse().transpose();
 		Self{
 			mesh_id,
 			attr_id,
 			transform,
-			normal_transform:transform.matrix3.inverse_times_det().transpose(),
+			normal_transform,
-			transform_det:transform.matrix3.determinant(),
 		}
 	}
 }
 
 #[derive(Debug,Clone,Eq,Hash,PartialEq)]
 struct ContactCollision{
-	face_id:crate::model_physics::MinkowskiFace,
+	//face_id:crate::model_physics::MinkowskiFace,
+	face_id:crate::model_physics::FaceId,
 	model_id:usize,//using id to avoid lifetimes
 }
 #[derive(Debug,Clone,Eq,Hash,PartialEq)]
@@ -825,7 +751,7 @@ impl Collision{
 			|&Collision::Intersect(IntersectCollision{model_id})=>model_id,
 		}
 	}
-	fn face_id(&self)->Option<crate::model_physics::MinkowskiFace>{
+	fn face_id(&self)->Option<crate::model_physics::FaceId>{
 		match self{
 			&Collision::Contact(ContactCollision{model_id:_,face_id})=>Some(face_id),
 			&Collision::Intersect(IntersectCollision{model_id:_})=>None,
@@ -885,20 +811,20 @@ impl TouchingState{
 		//add water../?
 		a
 	}
-	fn constrain_velocity(&self,models:&PhysicsModels,style_mesh:&TransformedMesh,velocity:&mut Planar64Vec3){
+	fn constrain_velocity(&self,models:&PhysicsModels,velocity:&mut Planar64Vec3){
 		//TODO: trey push solve
 		for contact in &self.contacts{
-			let n=contact_normal(models,style_mesh,contact);
+			let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
 			let d=n.dot128(*velocity);
 			if d<0{
 				*velocity-=n*Planar64::raw(((d<<32)/n.dot128(n)) as i64);
 			}
 		}
 	}
-	fn constrain_acceleration(&self,models:&PhysicsModels,style_mesh:&TransformedMesh,acceleration:&mut Planar64Vec3){
+	fn constrain_acceleration(&self,models:&PhysicsModels,acceleration:&mut Planar64Vec3){
 		//TODO: trey push solve
 		for contact in &self.contacts{
-			let n=contact_normal(models,style_mesh,contact);
+			let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
 			let d=n.dot128(*acceleration);
 			if d<0{
 				*acceleration-=n*Planar64::raw(((d<<32)/n.dot128(n)) as i64);
@@ -909,31 +835,30 @@ impl TouchingState{
 		//check current move conditions and use heuristics to determine
 		//which ladder to climb on, which ground to walk on, etc
 		//collect move state affecting objects from contacts (accelerator,water,ladder,ground)
-		let style_mesh=style.mesh();
 		let gravity=self.base_acceleration(models,style,camera,controls,next_mouse,time);
 		let mut move_state=MoveState::Air;
 		let mut a=gravity;
 		for contact in &self.contacts{
 			match models.attr(contact.model_id){
 				PhysicsCollisionAttributes::Contact{contacting,general}=>{
-					let normal=contact_normal(models,&style_mesh,contact);
+					let normal=models.mesh(contact.model_id).face_nd(contact.face_id).0;
 					match &contacting.contact_behaviour{
 						Some(crate::model::ContactingBehaviour::Ladder(_))=>{
 							//ladder walkstate
 							let mut target_velocity=style.get_ladder_target_velocity(camera,controls,next_mouse,time,&normal);
-							self.constrain_velocity(models,&style_mesh,&mut target_velocity);
+							self.constrain_velocity(models,&mut target_velocity);
 							let (walk_state,mut acceleration)=WalkState::ladder(body,style,gravity,target_velocity,contact.clone(),&normal);
 							move_state=MoveState::Ladder(walk_state);
-							self.constrain_acceleration(models,&style_mesh,&mut acceleration);
+							self.constrain_acceleration(models,&mut acceleration);
 							a=acceleration;
 						},
 						None=>if style.surf_slope.map_or(true,|s|normal.walkable(s,Planar64Vec3::Y)){
 							//check ground
 							let mut target_velocity=style.get_walk_target_velocity(camera,controls,next_mouse,time,&normal);
-							self.constrain_velocity(models,&style_mesh,&mut target_velocity);
+							self.constrain_velocity(models,&mut target_velocity);
 							let (walk_state,mut acceleration)=WalkState::ground(body,style,gravity,target_velocity,contact.clone(),&normal);
 							move_state=MoveState::Walk(walk_state);
-							self.constrain_acceleration(models,&style_mesh,&mut acceleration);
+							self.constrain_acceleration(models,&mut acceleration);
 							a=acceleration;
 						},
 						_=>(),
@@ -943,18 +868,15 @@ impl TouchingState{
 			}
 		}
 		for intersect in &self.intersects{
-			//water
+			//
 		}
-		self.constrain_acceleration(models,&style_mesh,&mut a);
+		self.constrain_acceleration(models,&mut a);
 		(move_state,a)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<PhysicsInstruction>,models:&PhysicsModels,style_mesh:&TransformedMesh,body:&Body,time:Time){
+	fn predict_collision_end(&self,collector:&mut crate::instruction::InstructionCollector<PhysicsInstruction>,models:&PhysicsModels,body:&Body,time:Time){
-		let relative_body=VirtualBody::relative(&Body::default(),body).body(time);
 		for contact in &self.contacts{
 			//detect face slide off
-			let model_mesh=models.mesh(contact.model_id);
+			collector.collect(models.mesh(contact.model_id).brute_out_face(body,collector.time(),contact.face_id).map(|(face,time)|{
-			let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
-			collector.collect(minkowski.predict_collision_face_out(&relative_body,collector.time(),contact.face_id).map(|(face,time)|{
 				TimedInstruction{
 					time,
 					instruction:PhysicsInstruction::CollisionEnd(
@@ -963,11 +885,10 @@ impl TouchingState{
 				}
 			}));
 		}
+		let relative_body=VirtualBody::relative(&Body::default(),body).body(time);
 		for intersect in &self.intersects{
 			//detect model collision in reverse
-			let model_mesh=models.mesh(intersect.model_id);
+			collector.collect(models.mesh(intersect.model_id).brute_out(&relative_body,collector.time()).map(|(face,time)|{
-			let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
-			collector.collect(minkowski.predict_collision_out(&relative_body,collector.time()).map(|(face,time)|{
 				TimedInstruction{
 					time,
 					instruction:PhysicsInstruction::CollisionEnd(
@@ -1001,42 +922,6 @@ impl Body{
 		self.velocity=self.extrapolated_velocity(time);
 		self.time=time;
 	}
-	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
-		if self.velocity==Planar64Vec3::ZERO{
-			if self.acceleration==Planar64Vec3::ZERO{
-				None
-			}else{
-				Some(self.acceleration)
-			}
-		}else{
-			Some(self.velocity)
-		}
-	}
-	pub fn grow_aabb(&self,aabb:&mut aabb::Aabb,t0:Time,t1:Time){
-		aabb.grow(self.extrapolated_position(t0));
-		aabb.grow(self.extrapolated_position(t1));
-		//v+a*t==0
-		//goober code
-		if self.acceleration.x()!=Planar64::ZERO{
-			let t=Time::from(-self.velocity.x()/self.acceleration.x());
-			if t0<t&&t<t1{
-				aabb.grow(self.extrapolated_position(t));
-			}
-		}
-		if self.acceleration.y()!=Planar64::ZERO{
-			let t=Time::from(-self.velocity.y()/self.acceleration.y());
-			if t0<t&&t<t1{
-				aabb.grow(self.extrapolated_position(t));
-			}
-		}
-		if self.acceleration.z()!=Planar64::ZERO{
-			let t=Time::from(-self.velocity.z()/self.acceleration.z());
-			if t0<t&&t<t1{
-				aabb.grow(self.extrapolated_position(t));
-			}
-		}
-	}
-
 }
 impl std::fmt::Display for Body{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -1080,7 +965,7 @@ impl Default for PhysicsState{
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
 			models:PhysicsModels::default(),
-			bvh:bvh::BvhNode::default(),
+			bvh:crate::bvh::BvhNode::default(),
 			move_state: MoveState::Air,
 			camera:PhysicsCamera::default(),
 			next_mouse:MouseState::default(),
@@ -1088,7 +973,6 @@ impl Default for PhysicsState{
 			world:WorldState{},
 			game:GameMechanicsState::default(),
 			modes:Modes::default(),
-			start_time:None,
 		}
 	}
 }
@@ -1098,7 +982,7 @@ impl PhysicsState {
 		self.models.clear();
 		self.modes.clear();
 		self.touching.clear();
-		self.bvh=bvh::BvhNode::default();
+		self.bvh=crate::bvh::BvhNode::default();
 	}
 
 	pub fn output(&self)->PhysicsOutputState{
@@ -1112,7 +996,7 @@ impl PhysicsState {
 	pub fn spawn(&mut self,spawn_point:Planar64Vec3){
 		self.game.stage_id=0;
 		self.spawn_point=spawn_point;
-		self.process_instruction(instruction::TimedInstruction{
+		self.process_instruction(crate::instruction::TimedInstruction{
 			time:self.time,
 			instruction: PhysicsInstruction::Input(PhysicsInputInstruction::Reset),
 		});
@@ -1150,7 +1034,7 @@ impl PhysicsState {
 				self.models.push_mesh(PhysicsMesh::from(model));
 			}
 		}
-		self.bvh=bvh::generate_bvh(self.models.aabb_list());
+		self.bvh=crate::bvh::generate_bvh(self.models.aabb_list());
 		//I don't wanna write structs for temporary structures
 		//this code builds ModeDescriptions from the unsorted lists at the top of the function
 		starts.sort_by_key(|tup|tup.1.mode_id);
@@ -1248,23 +1132,21 @@ impl PhysicsState {
 		match &mut self.move_state{
 			MoveState::Air|MoveState::Water=>self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time),
 			MoveState::Walk(WalkState{state,contact,jump_direction:_})=>{
-				let style_mesh=self.style.mesh();
+				let n=self.models.mesh(contact.model_id).face_nd(contact.face_id).0;
-				let n=contact_normal(&self.models,&style_mesh,contact);
 				let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 				let mut a;
 				let mut v=self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&n);
-				self.touching.constrain_velocity(&self.models,&style_mesh,&mut v);
+				self.touching.constrain_velocity(&self.models,&mut v);
 				let normal_accel=-n.dot(gravity)/n.length();
 				(*state,a)=WalkEnum::with_target_velocity(&self.body,&self.style,v,&n,self.style.walk_speed,normal_accel);
 				a
 			},
 			MoveState::Ladder(WalkState{state,contact,jump_direction:_})=>{
-				let style_mesh=self.style.mesh();
+				let n=self.models.mesh(contact.model_id).face_nd(contact.face_id).0;
-				let n=contact_normal(&self.models,&style_mesh,contact);
 				let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 				let mut a;
 				let mut v=self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&n);
-				self.touching.constrain_velocity(&self.models,&style_mesh,&mut v);
+				self.touching.constrain_velocity(&self.models,&mut v);
 				(*state,a)=WalkEnum::with_target_velocity(&self.body,&self.style,v,&n,self.style.ladder_speed,self.style.ladder_accel);
 				a
 			},
@@ -1286,31 +1168,28 @@ impl PhysicsState {
 	}
 }
 
-impl instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState{
+impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState{
 	//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
 	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<PhysicsInstruction>>{
 		//JUST POLLING!!! NO MUTATION
-		let mut collector = instruction::InstructionCollector::new(time_limit);
+		let mut collector = crate::instruction::InstructionCollector::new(time_limit);
 
 		collector.collect(self.next_move_instruction());
 
-		let style_mesh=self.style.mesh();
 		//check for collision ends
-		self.touching.predict_collision_end(&mut collector,&self.models,&style_mesh,&self.body,self.time);
+		self.touching.predict_collision_end(&mut collector,&self.models,&self.body,self.time);
 		//check for collision starts
-		let mut aabb=aabb::Aabb::default();
+		let mut aabb=crate::aabb::Aabb::default();
-		self.body.grow_aabb(&mut aabb,self.time,collector.time());
+		aabb.grow(self.body.extrapolated_position(self.time));
-		aabb.inflate(self.style.hitbox.halfsize);
+		aabb.grow(self.body.extrapolated_position(collector.time()));
+		aabb.inflate(self.style.hitbox_halfsize);
 		//common body
 		let relative_body=VirtualBody::relative(&Body::default(),&self.body).body(self.time);
 		self.bvh.the_tester(&aabb,&mut |id|{
 			//no checks are needed because of the time limits.
-			let model_mesh=self.models.mesh(id);
+			//let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(self.style.mesh,&self.models.mesh(id));
-			let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,&style_mesh);
+			//collector.collect(crate::face_crawler::predict_collision(&minkowski,&relative_body,collector.time()).map(|(face,time)|{
-			collector.collect(minkowski.predict_collision_in(&relative_body,collector.time())
+			collector.collect(self.models.mesh(id).brute_in(&relative_body,collector.time()).map(|(face,time)|{
-				//temp (?) code to avoid collision loops
-				.map_or(None,|(face,time)|if time==self.time{None}else{Some((face,time))})
-				.map(|(face,time)|{
 				TimedInstruction{time,instruction:PhysicsInstruction::CollisionStart(match self.models.attr(id){
 					PhysicsCollisionAttributes::Contact{contacting:_,general:_}=>Collision::Contact(ContactCollision{model_id:id,face_id:face}),
 					PhysicsCollisionAttributes::Intersect{intersecting:_,general:_}=>Collision::Intersect(IntersectCollision{model_id:id}),
@@ -1330,18 +1209,12 @@ fn get_walk_state(move_state:&MoveState)->Option<&WalkState>{
 
 fn jumped_velocity(models:&PhysicsModels,style:&StyleModifiers,walk_state:&WalkState,v:&mut Planar64Vec3){
 	let jump_dir=match &walk_state.jump_direction{
-		JumpDirection::FromContactNormal=>contact_normal(models,&style.mesh(),&walk_state.contact),
+		JumpDirection::FromContactNormal=>models.mesh(walk_state.contact.model_id).face_nd(walk_state.contact.face_id).0,
 		&JumpDirection::Exactly(dir)=>dir,
 	};
 	*v=*v+jump_dir*(style.get_jump_deltav()/jump_dir.length());
 }
 
-fn contact_normal(models:&PhysicsModels,style_mesh:&TransformedMesh,contact:&ContactCollision)->Planar64Vec3{
-	let model_mesh=models.mesh(contact.model_id);
-	let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&model_mesh,style_mesh);
-	minkowski.face_nd(contact.face_id).0
-}
-
 fn set_position(body:&mut Body,touching:&mut TouchingState,point:Planar64Vec3)->Planar64Vec3{
 	//test intersections at new position
 	//hovering above the surface 0 units is not intersecting.  you will fall into it just fine
@@ -1352,11 +1225,11 @@ fn set_position(body:&mut Body,touching:&mut TouchingState,point:Planar64Vec3)->
 	//touching.recalculate(body);
 	point
 }
-fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,v:Planar64Vec3)->bool{
+fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,v:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
 	touching.contacts.retain(|contact|{
-		let n=contact_normal(models,style_mesh,contact);
+		let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
 		let r=n.dot(v)<=Planar64::ZERO;
 		if !r{
 			culled=true;
@@ -1364,19 +1237,19 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 		}
 		r
 	});
-	set_velocity(body,touching,models,style_mesh,v);
+	set_velocity(body,touching,models,v);
 	culled
 }
-fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,mut v:Planar64Vec3)->Planar64Vec3{
+fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,mut v:Planar64Vec3)->Planar64Vec3{
-	touching.constrain_velocity(models,style_mesh,&mut v);
+	touching.constrain_velocity(&models,&mut v);
 	body.velocity=v;
 	v
 }
-fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,a:Planar64Vec3)->bool{
+fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,a:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
 	touching.contacts.retain(|contact|{
-		let n=contact_normal(models,style_mesh,contact);
+		let n=models.mesh(contact.model_id).face_nd(contact.face_id).0;
 		let r=n.dot(a)<=Planar64::ZERO;
 		if !r{
 			culled=true;
@@ -1384,23 +1257,23 @@ fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&Phys
 		}
 		r
 	});
-	set_acceleration(body,touching,models,style_mesh,a);
+	set_acceleration(body,touching,models,a);
 	culled
 }
-fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,style_mesh:&TransformedMesh,mut a:Planar64Vec3)->Planar64Vec3{
+fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,mut a:Planar64Vec3)->Planar64Vec3{
-	touching.constrain_acceleration(models,style_mesh,&mut a);
+	touching.constrain_acceleration(&models,&mut a);
 	body.acceleration=a;
 	a
 }
 
 fn teleport(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,style:&StyleModifiers,point:Planar64Vec3)->MoveState{
 	set_position(body,touching,point);
-	set_acceleration(body,touching,models,&style.mesh(),style.gravity);
+	set_acceleration(body,touching,models,style.gravity);
 	MoveState::Air
 }
 fn teleport_to_spawn(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,mode:&crate::model::ModeDescription,models:&PhysicsModels,stage_id:u32)->Option<MoveState>{
 	let model=models.model(*mode.get_spawn_model_id(stage_id)? as usize);
-	let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox.halfsize.y()+Planar64::ONE/16);
+	let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox_halfsize.y()+Planar64::ONE/16);
 	Some(teleport(body,touching,models,style,point))
 }
 
@@ -1469,7 +1342,7 @@ fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehav
 	}
 }
 
-impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
+impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 	fn process_instruction(&mut self, ins:TimedInstruction<PhysicsInstruction>) {
 		match &ins.instruction{
 			PhysicsInstruction::Input(PhysicsInputInstruction::Idle)
@@ -1489,42 +1362,41 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 		}
 		match ins.instruction{
 			PhysicsInstruction::CollisionStart(c)=>{
-				let style_mesh=self.style.mesh();
 				let model_id=c.model_id();
 				match (self.models.attr(model_id),&c){
 					(PhysicsCollisionAttributes::Contact{contacting,general},Collision::Contact(contact))=>{
 						let mut v=self.body.velocity;
-						let normal=contact_normal(&self.models,&style_mesh,contact);
+						let normal=self.models.mesh(model_id).face_nd(contact.face_id).0;
 						match &contacting.contact_behaviour{
 							Some(crate::model::ContactingBehaviour::Surf)=>println!("I'm surfing!"),
 							Some(crate::model::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
 							&Some(crate::model::ContactingBehaviour::Elastic(elasticity))=>{
+								let n=self.models.mesh(contact.model_id).face_nd(contact.face_id).0;
 								//velocity and normal are facing opposite directions so this is inherently negative.
-								let d=normal.dot(v)*(Planar64::ONE+Planar64::raw(elasticity as i64+1));
+								let d=n.dot(v)*(Planar64::ONE+Planar64::raw(elasticity as i64+1));
-								v+=normal*(d/normal.dot(normal));
+								v+=n*(d/n.dot(n));
 							},
 							Some(crate::model::ContactingBehaviour::Ladder(contacting_ladder))=>{
 								if contacting_ladder.sticky{
 									//kill v
-									//actually you could do this with a booster attribute :thinking:
 									v=Planar64Vec3::ZERO;//model.velocity
 								}
 								//ladder walkstate
 								let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 								let mut target_velocity=self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&normal);
-								self.touching.constrain_velocity(&self.models,&style_mesh,&mut target_velocity);
+								self.touching.constrain_velocity(&self.models,&mut target_velocity);
 								let (walk_state,a)=WalkState::ladder(&self.body,&self.style,gravity,target_velocity,contact.clone(),&normal);
 								self.move_state=MoveState::Ladder(walk_state);
-								set_acceleration(&mut self.body,&self.touching,&self.models,&style_mesh,a);
+								set_acceleration(&mut self.body,&self.touching,&self.models,a);
 							}
-							None=>if self.style.surf_slope.map_or(true,|s|contact_normal(&self.models,&style_mesh,contact).walkable(s,Planar64Vec3::Y)){
+							None=>if self.style.surf_slope.map_or(true,|s|self.models.mesh(model_id).face_nd(contact.face_id).0.walkable(s,Planar64Vec3::Y)){
 								//ground
 								let gravity=self.touching.base_acceleration(&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 								let mut target_velocity=self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time,&normal);
-								self.touching.constrain_velocity(&self.models,&style_mesh,&mut target_velocity);
+								self.touching.constrain_velocity(&self.models,&mut target_velocity);
 								let (walk_state,a)=WalkState::ground(&self.body,&self.style,gravity,target_velocity,contact.clone(),&normal);
 								self.move_state=MoveState::Walk(walk_state);
-								set_acceleration(&mut self.body,&self.touching,&self.models,&style_mesh,a);
+								set_acceleration(&mut self.body,&self.touching,&self.models,a);
 							},
 						}
 						//check ground
@@ -1532,7 +1404,7 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 						//I love making functions with 10 arguments to dodge the borrow checker
 						run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model_id);
 						//flatten v
-						self.touching.constrain_velocity(&self.models,&style_mesh,&mut v);
+						self.touching.constrain_velocity(&self.models,&mut v);
 						match &general.booster{
 							Some(booster)=>{
 								//DELETE THIS when boosters get converted to height machines
@@ -1547,7 +1419,7 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 						let calc_move=if self.style.get_control(StyleModifiers::CONTROL_JUMP,self.controls){
 							if let Some(walk_state)=get_walk_state(&self.move_state){
 								jumped_velocity(&self.models,&self.style,walk_state,&mut v);
-								set_velocity_cull(&mut self.body,&mut self.touching,&self.models,&style_mesh,v)
+								set_velocity_cull(&mut self.body,&mut self.touching,&self.models,v)
 							}else{false}
 						}else{false};
 						match &general.trajectory{
@@ -1563,30 +1435,15 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 							},
 							None=>(),
 						}
-						set_velocity(&mut self.body,&self.touching,&self.models,&style_mesh,v);
+						set_velocity(&mut self.body,&self.touching,&self.models,v);
 						//not sure if or is correct here
 						if calc_move||Planar64::ZERO<normal.dot(v){
 							(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 						}
 						let a=self.refresh_walk_target();
-						set_acceleration(&mut self.body,&self.touching,&self.models,&self.style.mesh(),a);
+						set_acceleration(&mut self.body,&self.touching,&self.models,a);
 					},
 					(PhysicsCollisionAttributes::Intersect{intersecting: _,general},Collision::Intersect(intersect))=>{
-						//check for mapstart and set start time
-						let model_id=c.model_id();
-						let start_model_id=self.modes.get_mode(0).unwrap().start;
-						if model_id==start_model_id{
-							//object touched is a mapstart
-							println!("Start!");
-							self.start_time=Some(self.time);
-						}
-
-						//check for map finish and print end time
-						if general.zone.as_ref().is_some_and(|zone|zone.behaviour==crate::model::ZoneBehaviour::Finish){
-							if let Some(start_time)=self.start_time.take(){
-								println!("Finish! Time={}",self.time-start_time);
-							}
-						}
 						//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
 						self.touching.insert(c);
 						run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model_id);
@@ -1617,7 +1474,7 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 						let v=self.body.velocity+control_dir*(self.style.mv-d);
 						//this is wrong but will work ig
 						//need to note which push planes activate in push solve and keep those
-						if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,&self.style.mesh(),v){
+						if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,v){
 							(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 						}
 					}
@@ -1630,12 +1487,11 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 						match &mut walk_state.state{
 							WalkEnum::Reached=>(),
 							WalkEnum::Transient(walk_target)=>{
-								let style_mesh=self.style.mesh();
 								//precisely set velocity
 								let a=Planar64Vec3::ZERO;//ignore gravity for now.
-								set_acceleration(&mut self.body,&self.touching,&self.models,&style_mesh,a);
+								set_acceleration(&mut self.body,&self.touching,&self.models,a);
 								let v=walk_target.velocity;
-								set_velocity(&mut self.body,&self.touching,&self.models,&style_mesh,v);
+								set_velocity(&mut self.body,&self.touching,&self.models,v);
 								walk_state.state=WalkEnum::Reached;
 							},
 						}
@@ -1664,7 +1520,7 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 						if let Some(walk_state)=get_walk_state(&self.move_state){
 							let mut v=self.body.velocity;
 							jumped_velocity(&self.models,&self.style,walk_state,&mut v);
-							if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,&self.style.mesh(),v){
+							if set_velocity_cull(&mut self.body,&mut self.touching,&self.models,v){
 								(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 							}
 						}
@@ -1677,7 +1533,7 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 					PhysicsInputInstruction::Reset => {
 						//it matters which of these runs first, but I have not thought it through yet as it doesn't matter yet
 						set_position(&mut self.body,&mut self.touching,self.spawn_point);
-						set_velocity(&mut self.body,&self.touching,&self.models,&self.style.mesh(),Planar64Vec3::ZERO);
+						set_velocity(&mut self.body,&self.touching,&self.models,Planar64Vec3::ZERO);
 						(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 						refresh_walk_target=false;
 					},
@@ -1685,7 +1541,7 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 				}
 				if refresh_walk_target{
 					let a=self.refresh_walk_target();
-					if set_acceleration_cull(&mut self.body,&mut self.touching,&self.models,&self.style.mesh(),a){
+					if set_acceleration_cull(&mut self.body,&mut self.touching,&self.models,a){
 						(self.move_state,self.body.acceleration)=self.touching.get_move_state(&self.body,&self.models,&self.style,&self.camera,self.controls,&self.next_mouse,self.time);
 					}
 				}
@@ -1693,218 +1549,3 @@ impl instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
 		}
 	}
 }
-
-#[allow(dead_code)]
-fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
-	let h0=Hitbox::from_mesh_scale(PhysicsMesh::from(&crate::primitives::unit_cube()),Planar64Vec3::int(5,1,5)/2);
-	let h1=Hitbox::roblox();
-	let hitbox_mesh=h1.transformed_mesh();
-	let platform_mesh=h0.transformed_mesh();
-	let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&platform_mesh,&hitbox_mesh);
-	let collision=minkowski.predict_collision_in(&relative_body,Time::MAX);
-	assert_eq!(collision.map(|tup|tup.1),expected_collision_time,"Incorrect time of collision");
-}
-#[allow(dead_code)]
-fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
-	let h0=Hitbox::new(PhysicsMesh::from(&crate::primitives::unit_cube()),
-		integer::Planar64Affine3::new(
-			integer::Planar64Mat3::from_cols(
-				Planar64Vec3::int(5,0,1)/2,
-				Planar64Vec3::int(0,1,0)/2,
-				Planar64Vec3::int(-1,0,5)/2,
-			),
-			Planar64Vec3::ZERO,
-		)
-	);
-	let h1=Hitbox::roblox();
-	let hitbox_mesh=h1.transformed_mesh();
-	let platform_mesh=h0.transformed_mesh();
-	let minkowski=crate::model_physics::MinkowskiMesh::minkowski_sum(&platform_mesh,&hitbox_mesh);
-	let collision=minkowski.predict_collision_in(&relative_body,Time::MAX);
-	assert_eq!(collision.map(|tup|tup.1),expected_collision_time,"Incorrect time of collision");
-}
-#[allow(dead_code)]
-fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
-	test_collision_axis_aligned(relative_body.clone(),expected_collision_time);
-	test_collision_rotated(relative_body,expected_collision_time);
-}
-#[test]
-fn test_collision_degenerate(){
-	test_collision(Body::new(
-		Planar64Vec3::int(0,5,0),
-		Planar64Vec3::int(0,-1,0),
-		Planar64Vec3::ZERO,
-		Time::ZERO
-	),Some(Time::from_secs(2)));
-}
-#[test]
-fn test_collision_degenerate_east(){
-	test_collision(Body::new(
-		Planar64Vec3::int(3,5,0),
-		Planar64Vec3::int(0,-1,0),
-		Planar64Vec3::ZERO,
-		Time::ZERO
-	),Some(Time::from_secs(2)));
-}
-#[test]
-fn test_collision_degenerate_south(){
-	test_collision(Body::new(
-		Planar64Vec3::int(0,5,3),
-		Planar64Vec3::int(0,-1,0),
-		Planar64Vec3::ZERO,
-		Time::ZERO
-	),Some(Time::from_secs(2)));
-}
-#[test]
-fn test_collision_degenerate_west(){
-	test_collision(Body::new(
-		Planar64Vec3::int(-3,5,0),
-		Planar64Vec3::int(0,-1,0),
-		Planar64Vec3::ZERO,
-		Time::ZERO
-	),Some(Time::from_secs(2)));
-}
-#[test]
-fn test_collision_degenerate_north(){
-	test_collision(Body::new(
-		Planar64Vec3::int(0,5,-3),
-		Planar64Vec3::int(0,-1,0),
-		Planar64Vec3::ZERO,
-		Time::ZERO
-	),Some(Time::from_secs(2)));
-}
-#[test]
-fn test_collision_parabola_edge_east_from_west(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(3,3,0),
-		Planar64Vec3::int(100,-1,0),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_south_from_north(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(0,3,3),
-		Planar64Vec3::int(0,-1,100),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_west_from_east(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(-3,3,0),
-		Planar64Vec3::int(-100,-1,0),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_north_from_south(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(0,3,-3),
-		Planar64Vec3::int(0,-1,-100),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_north_from_ne(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(0,6,-7)/2,
-		Planar64Vec3::int(-10,-1,1),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_north_from_nw(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(0,6,-7)/2,
-		Planar64Vec3::int(10,-1,1),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_east_from_se(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(7,6,0)/2,
-		Planar64Vec3::int(-1,-1,-10),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_east_from_ne(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(7,6,0)/2,
-		Planar64Vec3::int(-1,-1,10),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_south_from_se(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(0,6,7)/2,
-		Planar64Vec3::int(-10,-1,-1),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_south_from_sw(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(0,6,7)/2,
-		Planar64Vec3::int(10,-1,-1),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_west_from_se(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(-7,6,0)/2,
-		Planar64Vec3::int(1,-1,-10),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_parabola_edge_west_from_ne(){
-	test_collision(VirtualBody::relative(&Body::default(),&Body::new(
-		Planar64Vec3::int(-7,6,0)/2,
-		Planar64Vec3::int(1,-1,10),
-		Planar64Vec3::int(0,-1,0),
-		Time::ZERO
-	)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
-}
-#[test]
-fn test_collision_oblique(){
-	test_collision(Body::new(
-		Planar64Vec3::int(0,5,0),
-		Planar64Vec3::int(1,-64,2)/64,
-		Planar64Vec3::ZERO,
-		Time::ZERO
-	),Some(Time::from_secs(2)));
-}
-#[test]
-fn zoom_hit_nothing(){
-	test_collision(Body::new(
-		Planar64Vec3::int(0,10,0),
-		Planar64Vec3::int(1,0,0),
-		Planar64Vec3::int(0,1,0),
-		Time::ZERO
-	),None);
-}
-#[test]
-fn already_inside_hit_nothing(){
-	test_collision(Body::new(
-		Planar64Vec3::ZERO,
-		Planar64Vec3::int(1,0,0),
-		Planar64Vec3::int(0,1,0),
-		Time::ZERO
-	),None);
-}

src/physics_worker.rs

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

src/primitives.rs

@@ -1,5 +1,5 @@
 use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
-use strafesnet_common::integer::Planar64Vec3;
+use crate::integer::Planar64Vec3;
 
 #[derive(Debug)]
 pub enum Primitives{

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
@@ -47,21 +46,21 @@ fn create_instance()->SetupContextPartial1{
 	}
 }
 impl SetupContextPartial1{
-	fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
+	fn create_surface(self,window:&winit::window::Window)->Result<SetupContextPartial2,wgpu::CreateSurfaceError>{
 		Ok(SetupContextPartial2{
 			backends:self.backends,
-			surface:self.instance.create_surface(window)?,
+			surface:unsafe{self.instance.create_surface(window)}?,
 			instance:self.instance,
 		})
 	}
 }
-struct SetupContextPartial2<'a>{
+struct SetupContextPartial2{
 	backends:wgpu::Backends,
 	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
+	surface:wgpu::Surface,
 }
-impl<'a> SetupContextPartial2<'a>{
+impl SetupContextPartial2{
-	fn pick_adapter(self)->SetupContextPartial3<'a>{
+	fn pick_adapter(self)->SetupContextPartial3{
 		let adapter;
 
 		//TODO: prefer adapter that implements optional features
@@ -123,13 +122,13 @@ impl<'a> SetupContextPartial2<'a>{
 		}
 	}
 }
-struct SetupContextPartial3<'a>{
+struct SetupContextPartial3{
 	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
+	surface:wgpu::Surface,
 	adapter:wgpu::Adapter,
 }
-impl<'a> SetupContextPartial3<'a>{
+impl SetupContextPartial3{
-	fn request_device(self)->SetupContextPartial4<'a>{
+	fn request_device(self)->SetupContextPartial4{
 		let optional_features=optional_features();
 		let required_features=required_features();
 
@@ -141,8 +140,8 @@ impl<'a> SetupContextPartial3<'a>{
 			.request_device(
 				&wgpu::DeviceDescriptor {
 					label: None,
-					required_features: (optional_features & self.adapter.features()) | required_features,
+					features: (optional_features & self.adapter.features()) | required_features,
-					required_limits: needed_limits,
+					limits: needed_limits,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
@@ -157,15 +156,15 @@ impl<'a> SetupContextPartial3<'a>{
 		}
 	}
 }
-struct SetupContextPartial4<'a>{
+struct SetupContextPartial4{
 	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
+	surface:wgpu::Surface,
 	adapter:wgpu::Adapter,
 	device:wgpu::Device,
 	queue:wgpu::Queue,
 }
-impl<'a> SetupContextPartial4<'a>{
+impl SetupContextPartial4{
-	fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
+	fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->SetupContext{
 		let mut config=self.surface
 			.get_default_config(&self.adapter, size.width, size.height)
 			.expect("Surface isn't supported by the adapter.");
@@ -183,42 +182,65 @@ impl<'a> SetupContextPartial4<'a>{
 		}
 	}
 }
-pub struct SetupContext<'a>{
+pub struct SetupContext{
 	pub instance:wgpu::Instance,
-	pub surface:wgpu::Surface<'a>,
+	pub surface:wgpu::Surface,
 	pub device:wgpu::Device,
 	pub queue:wgpu::Queue,
 	pub config:wgpu::SurfaceConfiguration,
 }
 
-pub fn setup_and_start(title:String){
+pub fn setup(title:&str)->SetupContextSetup{
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
+	let window=create_window(title,&event_loop).unwrap();
+
 	println!("Initializing the surface...");
 
 	let partial_1=create_instance();
 
-	let window=create_window(title.as_str(),&event_loop).unwrap();
-
 	let partial_2=partial_1.create_surface(&window).unwrap();
 
 	let partial_3=partial_2.pick_adapter();
 
 	let partial_4=partial_3.request_device();
 
-	let size=window.inner_size();
+	SetupContextSetup{
+		window,
+		event_loop,
+		partial_context:partial_4,
+	}
+}
 
-	let setup_context=partial_4.configure_surface(&size);
+pub struct SetupContextSetup{
+	window:winit::window::Window,
+	event_loop:winit::event_loop::EventLoop<()>,
+	partial_context:SetupContextPartial4,
+}
 
-	//dedicated thread to ping request redraw back and resize the window doesn't seem logical
+impl SetupContextSetup{
+	fn into_split(self)->(winit::window::Window,winit::event_loop::EventLoop<()>,SetupContext){
+		let size=self.window.inner_size();
+		//Steal values and drop self
+		(
+			self.window,
+			self.event_loop,
+			self.partial_context.configure_surface(&size),
+		)
+	}
+	pub fn start(self){
+		let (window,event_loop,setup_context)=self.into_split();
 
-	let window=crate::window::WindowContextSetup::new(&setup_context,&window);
+		//dedicated thread to ping request redraw back and resize the window doesn't seem logical
-	//the thread that spawns the physics thread
-	let window_thread=window.into_worker(setup_context);
 
-	println!("Entering event loop...");
+		let window=crate::window::WindowContextSetup::new(&setup_context,window);
-	let root_time=std::time::Instant::now();
+		//the thread that spawns the physics thread
-	run_event_loop(event_loop,window_thread,root_time).unwrap();
+		let window_thread=window.into_worker(setup_context);
+
+		println!("Entering event loop...");
+		let root_time=std::time::Instant::now();
+		run_event_loop(event_loop,window_thread,root_time).unwrap();
+	}
 }
 
 fn run_event_loop(
@@ -227,7 +249,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/window.rs

@@ -1,6 +1,5 @@
+use crate::instruction::TimedInstruction;
 use crate::physics_worker::InputInstruction;
-use strafesnet_common::integer;
-use strafesnet_common::instruction::TimedInstruction;
 
 pub enum WindowInstruction{
 	Resize(winit::dpi::PhysicalSize<u32>),
@@ -16,7 +15,7 @@ struct WindowContext<'a>{
 	mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
 	screen_size:glam::UVec2,
 	user_settings:crate::settings::UserSettings,
-	window:&'a winit::window::Window,
+	window:winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
 }
 
@@ -24,7 +23,7 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0)
 	}
-	fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) {
+	fn window_event(&mut self,time:crate::integer::Time,event: winit::event::WindowEvent) {
 		match event {
 			winit::event::WindowEvent::DroppedFile(path)=>{
 				//blocking because it's simpler...
@@ -122,7 +121,7 @@ impl WindowContext<'_>{
 		}
 	}
 
-	fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
+	fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
 		match event {
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
@@ -159,15 +158,15 @@ impl WindowContext<'_>{
 	}
 }
 
-pub struct WindowContextSetup<'a>{
+pub struct WindowContextSetup{
 	user_settings:crate::settings::UserSettings,
-	window:&'a winit::window::Window,
+	window:winit::window::Window,
 	physics:crate::physics::PhysicsState,
 	graphics:crate::graphics::GraphicsState,
 }
 
-impl<'a> WindowContextSetup<'a>{
+impl WindowContextSetup{
-	pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
+	pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
 		//wee
 		let user_settings=crate::settings::read_user_settings();
 
@@ -195,7 +194,7 @@ impl<'a> WindowContextSetup<'a>{
 		}
 	}
 
-	fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{
+	fn into_context<'a>(self,setup_context:crate::setup::SetupContext)->WindowContext<'a>{
 		let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
 		let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
 		WindowContext{
@@ -209,7 +208,7 @@ impl<'a> WindowContextSetup<'a>{
 		}
 	}
 
-	pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
+	pub fn into_worker<'a>(self,setup_context:crate::setup::SetupContext)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
 		let mut window_context=self.into_context(setup_context);
 		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
 			match ins.instruction{

src/worker.rs

@@ -175,16 +175,16 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 
 #[test]//How to run this test with printing: cargo test --release -- --nocapture
 fn test_worker() {
+	println!("hiiiii");
 	// Create the worker thread
-	let test_body=crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO);
 	let worker=QRWorker::new(crate::physics::Body::default(),
 		|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
 	);
 
 	// Send tasks to the worker
 	for _ in 0..5 {
-		let task = strafesnet_common::instruction::TimedInstruction{
+		let task = crate::instruction::TimedInstruction{
-			time:strafesnet_common::integer::Time::ZERO,
+			time:crate::integer::Time::ZERO,
 			instruction:crate::physics::PhysicsInstruction::StrafeTick,
 		};
 		worker.send(task).unwrap();
@@ -197,13 +197,13 @@ fn test_worker() {
 	thread::sleep(std::time::Duration::from_millis(10));
 
 	// Send a new task
-	let task = strafesnet_common::instruction::TimedInstruction{
+	let task = crate::instruction::TimedInstruction{
-		time:strafesnet_common::integer::Time::ZERO,
+		time:crate::integer::Time::ZERO,
 		instruction:crate::physics::PhysicsInstruction::StrafeTick,
 	};
 	worker.send(task).unwrap();
 
-	//assert_eq!(test_body,worker.grab_clone());
+	println!("value={}",worker.grab_clone());
 
 	// wait long enough to see print from final task
 	thread::sleep(std::time::Duration::from_millis(10));

src/zeroes.rs

@@ -0,0 +1,34 @@
+//find roots of polynomials
+use crate::integer::Planar64;
+
+#[inline]
+pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
+	if a2==Planar64::ZERO{
+		return zeroes1(a0, a1);
+	}
+	let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
+	if 0<radicand {
+		//start with f64 sqrt
+		let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
+		//TODO: one or two newtons
+		//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 {
+		return vec![-a0/a1];
+	}
+}