how

Cargo.toml

@@ -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,10 @@ rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
-strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "434ca29aef7e3015c9ca1ed45de8fef42e33fdfb" }
 vbsp = "0.5.0"
 vmdl = "0.1.1"
-wgpu = "0.19.0"
-winit = "0.29.2"
+wgpu = "0.18.0"
+winit = { version = "0.29.2", features = ["rwh_05"] }
 
 #[profile.release]
 #lto = true

LICENSE

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

src/aabb.rs

@@ -0,0 +1,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,7 +1,7 @@
 use crate::physics::Body;
 use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
-use strafesnet_common::integer::{Time,Planar64};
-use strafesnet_common::zeroes::zeroes2;
+use crate::integer::{Time,Planar64};
+use crate::zeroes::zeroes2;
 
 enum Transition<F,E:DirectedEdge,V>{
 	Miss,

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};
 
@@ -204,7 +203,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 +219,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 +700,6 @@ impl GraphicsState{
 					label: Some("Skybox Texture"),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&skybox_image.data,
 			);
 
@@ -743,7 +740,6 @@ impl GraphicsState{
 					label: Some("Squid Texture"),
 					view_formats: &[],
 				},
-				wgpu::util::TextureDataOrder::LayerMajor,
 				&image.data,
 			);
 
@@ -834,7 +830,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 +899,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,8 +1,6 @@
-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()
+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();
@@ -14,7 +12,13 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
 
 	match vbsp::Bsp::read(s.as_slice()){
 		Ok(bsp)=>{
-			let mut spawn_point=integer::Planar64Vec3::ZERO;
+			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();
@@ -48,11 +52,10 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
 					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 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(vertex_xyz));
+						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;
@@ -83,8 +86,8 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
 					groups,
 					instances:vec![crate::model::ModelInstance{
 						attributes:crate::model::CollisionAttributes::Decoration,
-						transform:integer::Planar64Affine3::new(
-							integer::Planar64Mat3::default(),
+						transform:crate::integer::Planar64Affine3::new(
+							crate::integer::Planar64Mat3::default(),
 							valve_transform(<[f32;3]>::from(world_model.origin))
 						),
 						..Default::default()
@@ -193,8 +196,8 @@ pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Res
 				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(
+						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(

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 {

src/main.rs

@@ -1,13 +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 instruction;
 mod load_bsp;
 mod load_roblox;
 mod face_crawler;
@@ -114,5 +117,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)]

src/model_physics.rs

@@ -1,6 +1,5 @@
+use crate::integer::{Planar64,Planar64Vec3};
 use std::borrow::{Borrow,Cow};
-use strafesnet_common::zeroes;
-use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
 
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
 pub struct VertId(usize);
@@ -237,15 +236,15 @@ impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
 
 pub struct TransformedMesh<'a>{
 	mesh:&'a PhysicsMesh,
-	transform:&'a integer::Planar64Affine3,
-	normal_transform:&'a integer::Planar64Mat3,
+	transform:&'a crate::integer::Planar64Affine3,
+	normal_transform:&'a crate::integer::Planar64Mat3,
 	transform_det:Planar64,
 }
 impl TransformedMesh<'_>{
 	pub fn new<'a>(
 		mesh:&'a PhysicsMesh,
-		transform:&'a integer::Planar64Affine3,
-		normal_transform:&'a integer::Planar64Mat3,
+		transform:&'a crate::integer::Planar64Affine3,
+		normal_transform:&'a crate::integer::Planar64Mat3,
 		transform_det:Planar64,
 		)->TransformedMesh<'a>{
 		TransformedMesh{
@@ -390,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 zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
+			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);
@@ -408,7 +407,7 @@ impl MinkowskiMesh<'_>{
 			//is boundary uncrossable by a crawl from infinity
 			//check if time of collision is outside Time::MIN..Time::MAX
 			let d=edge_n.dot(diff);
-			if zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
+			if crate::zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
 				//test the edge
 				let edge_nn=edge_n.dot(edge_n);
 				if Planar64::ZERO<=d&&d<=edge_nn{
@@ -460,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)<=Planar64::ZERO&&zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
+					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);
 					}
@@ -476,13 +475,13 @@ impl MinkowskiMesh<'_>{
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=Planar64Vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN,infinity_body.time){
+			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,crate::integer::Time::MIN,infinity_body.time){
 				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
 				crate::face_crawler::CrawlResult::Hit(_,_)=>None,
 			}
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
+	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){
@@ -491,7 +490,7 @@ impl MinkowskiMesh<'_>{
 			}
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
+	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),
@@ -507,7 +506,7 @@ impl MinkowskiMesh<'_>{
 			}
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,integer::Time)>{
+	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=time_limit;
@@ -520,8 +519,8 @@ 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
-			for t in zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
-				let t=relative_body.time+integer::Time::from(t);
+			for t in crate::zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
+				let t=relative_body.time+crate::integer::Time::from(t);
 				if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
 					best_time=t;
 					best_edge=Some(directed_edge_id);

src/physics_worker.rs

@@ -1,165 +1,133 @@
-use crate::physics::{MouseState,PhysicsInputInstruction};
-use strafesnet_common::integer::Time;
-use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
-use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
-
-#[derive(Debug)]
-pub enum InputInstruction {
-	MoveMouse(glam::IVec2),
-	MoveRight(bool),
-	MoveUp(bool),
-	MoveBack(bool),
-	MoveLeft(bool),
-	MoveDown(bool),
-	MoveForward(bool),
-	Jump(bool),
-	Zoom(bool),
-	Reset,
-}
-pub enum Instruction{
-	Input(InputInstruction),
-	Render,
-	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
-	GenerateModels(crate::model::IndexedModelInstances),
-	ClearModels,
-	//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{
-					&InputInstruction::MoveMouse(m)=>{
-						if mouse_blocking{
-							//tell the game state which is living in the past about its future
-							timeline.push_front(TimedInstruction{
-								time:last_mouse_time,
-								instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:m}),
-							});
-						}else{
-							//mouse has just started moving again after being still for longer than 10ms.
-							//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
-							timeline.push_front(TimedInstruction{
-								time:last_mouse_time,
-								instruction:PhysicsInputInstruction::ReplaceMouse(
-									MouseState{time:last_mouse_time,pos:physics.next_mouse.pos},
-									MouseState{time:ins.time,pos:m}
-								),
-							});
-							//delay physics execution until we have an interpolation target
-							mouse_blocking=true;
-						}
-						last_mouse_time=ins.time;
-						None
-					},
-					&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
-					&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
-					&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
-					&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
-					&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
-					&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
-					&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
-					&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
-					InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
-				},
-				Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
-				Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
-				Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
-				Instruction::Render=>Some(PhysicsInputInstruction::Idle),
-			}{
-				//non-mouse event
-				timeline.push_back(TimedInstruction{
-					time:ins.time,
-					instruction:phys_input,
-				});
-				
-				if mouse_blocking{
-					//assume the mouse has stopped moving after 10ms.
-					//shitty mice are 125Hz which is 8ms so this should cover that.
-					//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
-					//so mouse events are probably not handled separately from drawing and fire right before it :(
-					if Time::from_millis(10)<ins.time-physics.next_mouse.time{
-						//push an event to extrapolate no movement from
-						timeline.push_front(TimedInstruction{
-							time:last_mouse_time,
-							instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}),
-						});
-						last_mouse_time=ins.time;
-						//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
-						mouse_blocking=false;
-						true
-					}else{
-						false
-					}
-				}else{
-					//keep this up to date so that it can be used as a known-timestamp
-					//that the mouse was not moving when the mouse starts moving again
-					last_mouse_time=ins.time;
-					true
-				}
-			}else{
-				//mouse event
-				true
-			}{
-				//empty queue
-				while let Some(instruction)=timeline.pop_front(){
-					physics.run(instruction.time);
-					physics.process_instruction(TimedInstruction{
-						time:instruction.time,
-						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
-					});
-				}
-				//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=>{
-					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
-				},
-				Instruction::Resize(size,user_settings)=>{
-					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
-				},
-				Instruction::GenerateModels(indexed_model_instances)=>{
-					physics.generate_models(&indexed_model_instances);
-					physics.spawn(indexed_model_instances.spawn_point);
-					graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
-				},
-				Instruction::ClearModels=>{
-					physics.clear();
-					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
-				},
-				_=>(),
-			}
-		})
+use crate::integer::Time;
+use crate::physics::{MouseState,PhysicsInputInstruction};
+use crate::instruction::{TimedInstruction,InstructionConsumer};
+#[derive(Debug)]
+pub enum InputInstruction {
+	MoveMouse(glam::IVec2),
+	MoveRight(bool),
+	MoveUp(bool),
+	MoveBack(bool),
+	MoveLeft(bool),
+	MoveDown(bool),
+	MoveForward(bool),
+	Jump(bool),
+	Zoom(bool),
+	Reset,
+}
+pub enum Instruction{
+	Input(InputInstruction),
+	Render,
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
+	GenerateModels(crate::model::IndexedModelInstances),
+	ClearModels,
+	//Graphics(crate::graphics_worker::Instruction),
+}
+
+	pub fn new(mut physics:crate::physics::PhysicsState,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
+		let mut mouse_blocking=true;
+		let mut last_mouse_time=physics.next_mouse.time;
+		let mut timeline=std::collections::VecDeque::new();
+		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+			if if let Some(phys_input)=match &ins.instruction{
+				Instruction::Input(input_instruction)=>match input_instruction{
+					&InputInstruction::MoveMouse(m)=>{
+						if mouse_blocking{
+							//tell the game state which is living in the past about its future
+							timeline.push_front(TimedInstruction{
+								time:last_mouse_time,
+								instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:m}),
+							});
+						}else{
+							//mouse has just started moving again after being still for longer than 10ms.
+							//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
+							timeline.push_front(TimedInstruction{
+								time:last_mouse_time,
+								instruction:PhysicsInputInstruction::ReplaceMouse(
+									MouseState{time:last_mouse_time,pos:physics.next_mouse.pos},
+									MouseState{time:ins.time,pos:m}
+								),
+							});
+							//delay physics execution until we have an interpolation target
+							mouse_blocking=true;
+						}
+						last_mouse_time=ins.time;
+						None
+					},
+					&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
+					&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
+					&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
+					&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
+					&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
+					&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
+					&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
+					&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
+					InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
+				},
+				Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
+				Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
+				Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
+				Instruction::Render=>Some(PhysicsInputInstruction::Idle),
+			}{
+				//non-mouse event
+				timeline.push_back(TimedInstruction{
+					time:ins.time,
+					instruction:phys_input,
+				});
+				
+				if mouse_blocking{
+					//assume the mouse has stopped moving after 10ms.
+					//shitty mice are 125Hz which is 8ms so this should cover that.
+					//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
+					//so mouse events are probably not handled separately from drawing and fire right before it :(
+					if Time::from_millis(10)<ins.time-physics.next_mouse.time{
+						//push an event to extrapolate no movement from
+						timeline.push_front(TimedInstruction{
+							time:last_mouse_time,
+							instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}),
+						});
+						last_mouse_time=ins.time;
+						//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
+						mouse_blocking=false;
+						true
+					}else{
+						false
+					}
+				}else{
+					//keep this up to date so that it can be used as a known-timestamp
+					//that the mouse was not moving when the mouse starts moving again
+					last_mouse_time=ins.time;
+					true
+				}
+			}else{
+				//mouse event
+				true
+			}{
+				//empty queue
+				while let Some(instruction)=timeline.pop_front(){
+					physics.run(instruction.time);
+					physics.process_instruction(TimedInstruction{
+						time:instruction.time,
+						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
+					});
+				}
+			}
+			match ins.instruction{
+				Instruction::Render=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
+				},
+				Instruction::Resize(size,user_settings)=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
+				},
+				Instruction::GenerateModels(indexed_model_instances)=>{
+					physics.generate_models(&indexed_model_instances);
+					physics.spawn(indexed_model_instances.spawn_point);
+					graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
+				},
+				Instruction::ClearModels=>{
+					physics.clear();
+					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
+				},
+				_=>(),
+			}
+		})
 	}

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>{
-	fn pick_adapter(self)->SetupContextPartial3<'a>{
+impl SetupContextPartial2{
+	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>{
-	fn request_device(self)->SetupContextPartial4<'a>{
+impl SetupContextPartial3{
+	fn request_device(self)->SetupContextPartial4{
 		let optional_features=optional_features();
 		let required_features=required_features();
 
@@ -141,8 +140,8 @@ impl<'a> SetupContextPartial3<'a>{
 			.request_device(
 				&wgpu::DeviceDescriptor {
 					label: None,
-					required_features: (optional_features & self.adapter.features()) | required_features,
-					required_limits: needed_limits,
+					features: (optional_features & self.adapter.features()) | required_features,
+					limits: needed_limits,
 				},
 				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
@@ -157,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>{
-	fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
+impl SetupContextPartial4{
+	fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->SetupContext{
 		let mut config=self.surface
 			.get_default_config(&self.adapter, size.width, size.height)
 			.expect("Surface isn't supported by the adapter.");
@@ -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);
-	//the thread that spawns the physics thread
-	let window_thread=window.into_worker(setup_context);
+		//dedicated thread to ping request redraw back and resize the window doesn't seem logical
 
-	println!("Entering event loop...");
-	let root_time=std::time::Instant::now();
-	run_event_loop(event_loop,window_thread,root_time).unwrap();
+		let window=crate::window::WindowContextSetup::new(&setup_context,window);
+		//the thread that spawns the physics thread
+		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>{
-	pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
+impl WindowContextSetup{
+	pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
 		//wee
 		let user_settings=crate::settings::read_user_settings();
 
@@ -195,7 +194,7 @@ impl<'a> WindowContextSetup<'a>{
 		}
 	}
 
-	fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{
+	fn into_context<'a>(self,setup_context:crate::setup::SetupContext)->WindowContext<'a>{
 		let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
 		let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
 		WindowContext{
@@ -209,7 +208,7 @@ impl<'a> WindowContextSetup<'a>{
 		}
 	}
 
-	pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
+	pub fn into_worker<'a>(self,setup_context:crate::setup::SetupContext)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
 		let mut window_context=self.into_context(setup_context);
 		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
 			match ins.instruction{

src/worker.rs

@@ -183,8 +183,8 @@ fn test_worker() {
 
 	// Send tasks to the worker
 	for _ in 0..5 {
-		let task = strafesnet_common::instruction::TimedInstruction{
-			time:strafesnet_common::integer::Time::ZERO,
+		let task = crate::instruction::TimedInstruction{
+			time:crate::integer::Time::ZERO,
 			instruction:crate::physics::PhysicsInstruction::StrafeTick,
 		};
 		worker.send(task).unwrap();
@@ -197,8 +197,8 @@ fn test_worker() {
 	thread::sleep(std::time::Duration::from_millis(10));
 
 	// Send a new task
-	let task = strafesnet_common::instruction::TimedInstruction{
-		time:strafesnet_common::integer::Time::ZERO,
+	let task = crate::instruction::TimedInstruction{
+		time:crate::integer::Time::ZERO,
 		instruction:crate::physics::PhysicsInstruction::StrafeTick,
 	};
 	worker.send(task).unwrap();

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![];
+		}
+	}
+}