explore worker pool ideas

Cargo.toml

@@ -19,7 +19,7 @@ rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
 wgpu = "0.17.0"
-winit = { version = "0.29.2", features = ["rwh_05"] }
+winit = "0.28.6"
 
 #[profile.release]
 #lto = true

src/compat_worker.rs

@@ -1,21 +0,0 @@
-pub type QNWorker<'a,Task>=CompatNWorker<'a,Task>;
-pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
-
-pub struct CompatNWorker<'a,Task>{
-	data:std::marker::PhantomData<Task>,
-	f:Box<dyn FnMut(Task)+'a>,
-}
-
-impl<'a,Task> CompatNWorker<'a,Task>{
-	pub fn new(f:impl FnMut(Task)+'a)->CompatNWorker<'a,Task>{
-		Self{
-			data:std::marker::PhantomData,
-			f:Box::new(f),
-		}
-	}
-
-	pub fn send(&mut self,task:Task)->Result<(),()>{
-		(self.f)(task);
-		Ok(())
-	}
-}

src/graphics.rs

@@ -8,6 +8,12 @@ pub struct ModelUpdate{
 	color:Option<glam::Vec4>,
 }
 
+#[derive(Clone)]
+pub enum GraphicsInstruction{
+	UpdateModel(ModelUpdate),
+	Render,
+}
+
 struct Entity {
 	index_count: u32,
 	index_buf: wgpu::Buffer,
@@ -85,14 +91,6 @@ impl GraphicsCamera{
 		raw
 	}
 }
-impl std::default::Default for GraphicsCamera{
-	fn default()->Self{
-		Self{
-			screen_size:glam::UVec2::ONE,
-			fov:glam::Vec2::ONE,
-		}
-	}
-}
 
 pub struct GraphicsState{
 	pipelines: GraphicsPipelines,
@@ -136,7 +134,7 @@ impl GraphicsState{
 	pub fn load_user_settings(&mut self,user_settings:&crate::settings::UserSettings){
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
-	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,indexed_models:crate::model::IndexedModelInstances){
+	fn generate_model_graphics(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,indexed_models:crate::model::IndexedModelInstances){
 		//generate texture view per texture
 
 		//idk how to do this gooder lol
@@ -456,7 +454,7 @@ impl GraphicsState{
 		//.into_iter() the modeldata vec so entities can be /moved/ to models.entities
 		let mut model_count=0;
 		let mut instance_count=0;
-		let uniform_buffer_binding_size=crate::setup::required_limits().max_uniform_buffer_binding_size as usize;
+		let uniform_buffer_binding_size=crate::graphics_context::required_limits().max_uniform_buffer_binding_size as usize;
 		let chunk_size=uniform_buffer_binding_size/MODEL_BUFFER_SIZE_BYTES;
 		self.models.reserve(models.len());
 		for model in models.into_iter() {
@@ -530,9 +528,10 @@ impl GraphicsState{
 	}
 
 	pub fn new(
-		device:&wgpu::Device,
-		queue:&wgpu::Queue,
-		config:&wgpu::SurfaceConfiguration,
+		config: &wgpu::SurfaceConfiguration,
+		_adapter: &wgpu::Adapter,
+		device: &wgpu::Device,
+		queue: &wgpu::Queue,
 	)->Self{
 		let camera_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
 			label: None,
@@ -815,8 +814,14 @@ impl GraphicsState{
 			multiview: None,
 		});
 
-		let camera=GraphicsCamera::default();
-		let camera_uniforms = camera.to_uniform_data(crate::physics::PhysicsOutputState::default().extrapolate(glam::IVec2::ZERO,crate::integer::Time::ZERO));
+		let mut physics = crate::physics::PhysicsState::default();
+
+		physics.load_user_settings(&user_settings);
+
+		let screen_size=glam::uvec2(config.width,config.height);
+
+		let camera=GraphicsCamera::new(screen_size,user_settings.calculate_fov(1.0,&screen_size).as_vec2());
+		let camera_uniforms = camera.to_uniform_data(physics.output().adjust_mouse(&crate::physics::MouseState::default()));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
 			contents: bytemuck::cast_slice(&camera_uniforms),
@@ -871,30 +876,32 @@ impl GraphicsState{
 	}
 	pub fn resize(
 		&mut self,
-		device:&wgpu::Device,
-		config:&wgpu::SurfaceConfiguration,
-		user_settings:&crate::settings::UserSettings,
+		context:&crate::graphics_context::GraphicsContext,
 	) {
-		self.depth_view = Self::create_depth_texture(config,device);
-		self.camera.screen_size=glam::uvec2(config.width, config.height);
-		self.load_user_settings(user_settings);
+		self.depth_view = Self::create_depth_texture(&context.config,&context.device);
+		self.camera.screen_size=glam::uvec2(context.config.width, context.config.height);
+		self.load_user_settings(&self.user_settings);
 	}
 	pub fn render(
 		&mut self,
-		view:&wgpu::TextureView,
-		device:&wgpu::Device,
-		queue:&wgpu::Queue,
-		physics_output:crate::physics::PhysicsOutputState,
-		predicted_time:crate::integer::Time,
-		mouse_pos:glam::IVec2,
+		view: &wgpu::TextureView,
+		device: &wgpu::Device,
+		queue: &wgpu::Queue,
 	) {
-		//TODO: use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
+		//ideally this would be scheduled to execute and finish right before the render.
+		let time=crate::integer::Time::from_nanos(self.start_time.elapsed().as_nanos() as i64);
+		self.physics_thread.send(crate::instruction::TimedInstruction{
+			time,
+			instruction:crate::render_thread::InputInstruction::Idle,
+		}).unwrap();
+		//update time lol
+		self.mouse.time=time;
 
 		let mut encoder =
 			device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 
 		// update rotation
-		let camera_uniforms = self.camera.to_uniform_data(physics_output.extrapolate(mouse_pos,predicted_time));
+		let camera_uniforms = self.camera.to_uniform_data(self.physics_thread.grab_clone().adjust_mouse(&self.mouse));
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,

src/graphics_context.rs

@@ -1,42 +1,28 @@
-use crate::instruction::TimedInstruction;
-use crate::window::WindowInstruction;
-
-fn optional_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_ASTC
-	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
+fn optional_features() -> wgpu::Features {
+	wgpu::Features::empty()
 }
-fn required_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_BC
+fn required_features() -> wgpu::Features {
+	wgpu::Features::empty()
 }
-fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
-	wgpu::DownlevelCapabilities{
-		flags:wgpu::DownlevelFlags::empty(),
-		shader_model:wgpu::ShaderModel::Sm5,
+fn required_downlevel_capabilities() -> wgpu::DownlevelCapabilities {
+	wgpu::DownlevelCapabilities {
+		flags: wgpu::DownlevelFlags::empty(),
+		shader_model: wgpu::ShaderModel::Sm5,
 		..wgpu::DownlevelCapabilities::default()
 	}
 }
-pub fn required_limits()->wgpu::Limits{
-	wgpu::Limits::default()
+pub fn required_limits() -> wgpu::Limits {
+	wgpu::Limits::downlevel_webgl2_defaults() // These downlevel limits will allow the code to run on all possible hardware
 }
 
-struct SetupContextPartial1{
+struct GraphicsContextPartial1{
 	backends:wgpu::Backends,
 	instance:wgpu::Instance,
 }
-fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
-	let mut builder = winit::window::WindowBuilder::new();
-	builder = builder.with_title(title);
-	#[cfg(windows_OFF)] // TODO
-	{
-		use winit::platform::windows::WindowBuilderExtWindows;
-		builder = builder.with_no_redirection_bitmap(true);
-	}
-	builder.build(event_loop)
-}
-fn create_instance()->SetupContextPartial1{
+fn create_instance()->GraphicsContextPartial1{
 	let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
 	let dx12_shader_compiler=wgpu::util::dx12_shader_compiler_from_env().unwrap_or_default();
-	SetupContextPartial1{
+	GraphicsContextPartial1{
 		backends,
 		instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
 			backends,
@@ -44,22 +30,22 @@ fn create_instance()->SetupContextPartial1{
 		}),
 	}
 }
-impl SetupContextPartial1{
-	fn create_surface(self,window:&winit::window::Window)->Result<SetupContextPartial2,wgpu::CreateSurfaceError>{
-		Ok(SetupContextPartial2{
+impl GraphicsContextPartial1{
+	fn create_surface(self,window:&winit::window::Window)->Result<GraphicsContextPartial2,wgpu::CreateSurfaceError>{
+		Ok(GraphicsContextPartial2{
 			backends:self.backends,
-			surface:unsafe{self.instance.create_surface(window)}?,
 			instance:self.instance,
+			surface:unsafe{self.instance.create_surface(window)}?
 		})
 	}
 }
-struct SetupContextPartial2{
+struct GraphicsContextPartial2{
 	backends:wgpu::Backends,
 	instance:wgpu::Instance,
 	surface:wgpu::Surface,
 }
-impl SetupContextPartial2{
-	fn pick_adapter(self)->SetupContextPartial3{
+impl GraphicsContextPartial2{
+	fn pick_adapter(self)->GraphicsContextPartial3{
 		let adapter;
 
 		let optional_features=optional_features();
@@ -113,20 +99,20 @@ impl SetupContextPartial2{
 			"Adapter does not support the downlevel capabilities required to run this example: {:?}",
 			required_downlevel_capabilities.flags - downlevel_capabilities.flags
 		);
-		SetupContextPartial3{
+		GraphicsContextPartial3{
 			instance:self.instance,
 			surface:self.surface,
 			adapter,
 		}
 	}
 }
-struct SetupContextPartial3{
+struct GraphicsContextPartial3{
 	instance:wgpu::Instance,
 	surface:wgpu::Surface,
 	adapter:wgpu::Adapter,
 }
-impl SetupContextPartial3{
-	fn request_device(self)->SetupContextPartial4{
+impl GraphicsContextPartial3{
+	fn request_device(self)->GraphicsContextPartial4{
 		let optional_features=optional_features();
 		let required_features=required_features();
 
@@ -145,7 +131,7 @@ impl SetupContextPartial3{
 			))
 			.expect("Unable to find a suitable GPU adapter!");
 
-		SetupContextPartial4{
+		GraphicsContextPartial4{
 			instance:self.instance,
 			surface:self.surface,
 			adapter:self.adapter,
@@ -154,15 +140,15 @@ impl SetupContextPartial3{
 		}
 	}
 }
-struct SetupContextPartial4{
+struct GraphicsContextPartial4{
 	instance:wgpu::Instance,
 	surface:wgpu::Surface,
 	adapter:wgpu::Adapter,
 	device:wgpu::Device,
 	queue:wgpu::Queue,
 }
-impl SetupContextPartial4{
-	fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->SetupContext{
+impl GraphicsContextPartial4{
+	fn configure_surface(self,size:&winit::dpi::PhysicalSize<u32>)->GraphicsContext{
 		let mut config=self.surface
 			.get_default_config(&self.adapter, size.width, size.height)
 			.expect("Surface isn't supported by the adapter.");
@@ -170,27 +156,29 @@ impl SetupContextPartial4{
 		config.view_formats.push(surface_view_format);
 		self.surface.configure(&self.device, &config);
 
-		SetupContext{
+		GraphicsContext{
 			instance:self.instance,
 			surface:self.surface,
+			adapter:self.adapter,
 			device:self.device,
 			queue:self.queue,
 			config,
 		}
 	}
 }
-pub struct SetupContext{
+pub struct GraphicsContext{
 	pub instance:wgpu::Instance,
 	pub surface:wgpu::Surface,
+	pub adapter:wgpu::Adapter,
 	pub device:wgpu::Device,
 	pub queue:wgpu::Queue,
 	pub config:wgpu::SurfaceConfiguration,
 }
 
-pub fn setup(title:&str)->SetupContextSetup{
-	let event_loop=winit::event_loop::EventLoop::new().unwrap();
+pub fn setup(title:&str)->GraphicsContextSetup{
+	let event_loop=winit::event_loop::EventLoop::new();
 
-	let window=create_window(title,&event_loop).unwrap();
+	let window=crate::window::WindowState::create_window(title,&event_loop).unwrap();
 
 	println!("Initializing the surface...");
 
@@ -202,99 +190,126 @@ pub fn setup(title:&str)->SetupContextSetup{
 
 	let partial_4=partial_3.request_device();
 
-	SetupContextSetup{
+	GraphicsContextSetup{
 		window,
 		event_loop,
-		partial_context:partial_4,
+		partial_graphics_context:partial_4,
 	}
 }
 
-pub struct SetupContextSetup{
+struct GraphicsContextSetup{
 	window:winit::window::Window,
 	event_loop:winit::event_loop::EventLoop<()>,
-	partial_context:SetupContextPartial4,
+	partial_graphics_context:GraphicsContextPartial4,
 }
 
-impl SetupContextSetup{
-	fn into_split(self)->(winit::window::Window,winit::event_loop::EventLoop<()>,SetupContext){
+impl GraphicsContextSetup{
+	fn into_split(self)->(winit::window::Window,winit::event_loop::EventLoop<()>,GraphicsContext){
 		let size=self.window.inner_size();
 		//Steal values and drop self
 		(
 			self.window,
 			self.event_loop,
-			self.partial_context.configure_surface(&size),
+			self.partial_graphics_context.configure_surface(&size),
 		)
 	}
-	pub fn start(self){
-		let (window,event_loop,setup_context)=self.into_split();
+	pub fn start(self,mut global_state:crate::GlobalState){
+		let (window,event_loop,graphics_context)=self.into_split();
 
-		//dedicated thread to ping request redraw back and resize the window doesn't seem logical
-
-		let window=crate::window::WindowContextSetup::new(&setup_context,window);
-		//the thread that spawns the physics thread
-		let 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(
-	event_loop:winit::event_loop::EventLoop<()>,
-	mut window_thread:crate::compat_worker::QNWorker<TimedInstruction<WindowInstruction>>,
-	root_time:std::time::Instant
-	)->Result<(),winit::error::EventLoopError>{
-		event_loop.run(move |event,elwt|{
-			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{
-			// 	winit::event_loop::ControlFlow::Poll
-			// };
+		println!("Entering render loop...");
+		event_loop.run(move |event,_,control_flow|{
+			*control_flow=if cfg!(feature="metal-auto-capture"){
+				winit::event_loop::ControlFlow::Exit
+			}else{
+				winit::event_loop::ControlFlow::Poll
+			};
 			match event{
-				winit::event::Event::AboutToWait=>{
-					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::RequestRedraw}).unwrap();
+				winit::event::Event::RedrawEventsCleared=>{
+					window.request_redraw();
 				}
 				winit::event::Event::WindowEvent {
 					event:
-						// WindowEvent::Resized(size)
-						// | WindowEvent::ScaleFactorChanged {
-						// 	new_inner_size: &mut size,
-						// 	..
-						// },
-						winit::event::WindowEvent::Resized(size),//ignoring scale factor changed for now because mutex bruh
-					window_id:_,
+						winit::event::WindowEvent::Resized(size)
+						| winit::event::WindowEvent::ScaleFactorChanged {
+							new_inner_size:&mut size,
+							..
+						},
+					..
 				} => {
-					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Resize(size)}).unwrap();
+					// Once winit is fixed, the detection conditions here can be removed.
+					// https://github.com/rust-windowing/winit/issues/2876
+					// this has been fixed if I update winit (remove the if statement and only use the else case)
+					//drop adapter when you delete this
+					let max_dimension=graphics_context.adapter.limits().max_texture_dimension_2d;
+					if max_dimension<size.width||max_dimension<size.height{
+						println!(
+							"The resizing size {:?} exceeds the limit of {}.",
+							size,
+							max_dimension
+						);
+					}else{
+						println!("Resizing to {:?}",size);
+						graphics_context.config.width=size.width.max(1);
+						graphics_context.config.height=size.height.max(1);
+						window.resize(&graphics_context);
+						graphics_context.surface.configure(&graphics_context.device,&graphics_context.config);
+					}
 				}
 				winit::event::Event::WindowEvent{event,..}=>match event{
 					winit::event::WindowEvent::KeyboardInput{
-						event:
-							winit::event::KeyEvent {
-							logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
+						input:
+							winit::event::KeyboardInput{
+								virtual_keycode:Some(winit::event::VirtualKeyCode::Escape),
 								state: winit::event::ElementState::Pressed,
 								..
 							},
 						..
 					}
 					|winit::event::WindowEvent::CloseRequested=>{
-						elwt.exit();
+						*control_flow=winit::event_loop::ControlFlow::Exit;
 					}
-					winit::event::WindowEvent::RedrawRequested=>{
-						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Render}).unwrap();
+					winit::event::WindowEvent::KeyboardInput{
+						input:
+							winit::event::KeyboardInput{
+								virtual_keycode:Some(winit::event::VirtualKeyCode::Scroll),
+								state: winit::event::ElementState::Pressed,
+								..
+							},
+						..
+					}=>{
+						println!("{:#?}",graphics_context.instance.generate_report());
 					}
 					_=>{
-						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::WindowEvent(event)}).unwrap();
+						global_state.update(event);
 					}
 				},
 				winit::event::Event::DeviceEvent{
 					event,
 					..
 				} => {
-					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::DeviceEvent(event)}).unwrap();
+					global_state.device_event(event);
 				},
+				winit::event::Event::RedrawRequested(_)=>{
+					let frame=match graphics_context.surface.get_current_texture(){
+						Ok(frame)=>frame,
+						Err(_)=>{
+							graphics_context.surface.configure(&graphics_context.device,&graphics_context.config);
+							graphics_context.surface
+								.get_current_texture()
+								.expect("Failed to acquire next surface texture!")
+						}
+					};
+					let view=frame.texture.create_view(&wgpu::TextureViewDescriptor{
+						format:Some(graphics_context.config.view_formats[0]),
+						..wgpu::TextureViewDescriptor::default()
+					});
+
+					graphics.render(&view,&graphics_context.device,&graphics_context.queue);
+
+					frame.present();
+				}
 				_=>{}
 			}
-		})
+		});
+	}
 }

src/graphics_worker.rs

@@ -1,62 +0,0 @@
-pub enum Instruction{
-	Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
-	//UpdateModel(crate::graphics::ModelUpdate),
-	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
-	GenerateModels(crate::model::IndexedModelInstances),
-	ClearModels,
-}
-
-//Ideally the graphics thread worker description is:
-/*
-WorkerDescription{
-	input:Immediate,
-	output:Realtime(PoolOrdering::Ordered(3)),
-}
-*/
-//up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
-
-pub fn new<'a>(
-		mut graphics:crate::graphics::GraphicsState,
-		mut config:wgpu::SurfaceConfiguration,
-		surface:wgpu::Surface,
-		device:wgpu::Device,
-		queue:wgpu::Queue,
-	)->crate::compat_worker::INWorker<'a,Instruction>{
-	crate::compat_worker::INWorker::new(move |ins:Instruction|{
-		match ins{
-			Instruction::GenerateModels(indexed_model_instances)=>{
-				graphics.generate_models(&device,&queue,indexed_model_instances);
-			},
-			Instruction::ClearModels=>{
-				graphics.clear();
-			},
-			Instruction::Resize(size,user_settings)=>{
-				println!("Resizing to {:?}",size);
-				config.width=size.width.max(1);
-				config.height=size.height.max(1);
-				surface.configure(&device,&config);
-				graphics.resize(&device,&config,&user_settings);
-			}
-			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
-				//this has to go deeper somehow
-				let frame=match surface.get_current_texture(){
-					Ok(frame)=>frame,
-					Err(_)=>{
-						surface.configure(&device,&config);
-						surface
-							.get_current_texture()
-							.expect("Failed to acquire next surface texture!")
-					}
-				};
-				let view=frame.texture.create_view(&wgpu::TextureViewDescriptor{
-					format:Some(config.view_formats[0]),
-					..wgpu::TextureViewDescriptor::default()
-				});
-
-				graphics.render(&view,&device,&queue,physics_output,predicted_time,mouse_pos);
-
-				frame.present();
-			}
-		}
-	})
-}

src/integer.rs

@@ -41,11 +41,6 @@ impl std::fmt::Display for Time{
 		write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
 	}
 }
-impl std::default::Default for Time{
-	fn default()->Self{
-		Self(0)
-	}
-}
 impl std::ops::Neg for Time{
 	type Output=Time;
 	#[inline]

src/main.rs

@@ -1,7 +1,11 @@
+use std::time::Instant;
+use physics::PhysicsInstruction;
+use render_thread::InputInstruction;
+use instruction::{TimedInstruction, InstructionConsumer};
+
 mod bvh;
 mod aabb;
 mod model;
-mod setup;
 mod window;
 mod worker;
 mod zeroes;
@@ -12,10 +16,27 @@ mod settings;
 mod primitives;
 mod instruction;
 mod load_roblox;
-mod compat_worker;
+mod render_thread;
 mod model_graphics;
-mod physics_worker;
-mod graphics_worker;
+mod graphics_context;
+
+
+pub struct GlobalState{
+	start_time: std::time::Instant,
+	manual_mouse_lock:bool,
+	mouse:std::sync::Arc<std::sync::Mutex<physics::MouseState>>,
+	user_settings:settings::UserSettings,
+	//Ideally the graphics thread worker description is:
+	/*
+	WorkerDescription{
+		input:Immediate,
+		output:Realtime(PoolOrdering::Ordered(3)),
+	}
+	*/
+	//up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
+	graphics_thread:worker::INWorker<graphics::GraphicsInstruction>,
+	physics_thread:worker::QNWorker<TimedInstruction<InputInstruction>>,
+}
 
 fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
 	println!("Loading file: {:?}", &path);
@@ -62,7 +83,7 @@ fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
 	}
 }
 
-pub fn default_models()->model::IndexedModelInstances{
+fn default_models()->model::IndexedModelInstances{
 	let mut indexed_models = Vec::new();
 	indexed_models.append(&mut model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap(),glam::Vec4::ONE));
 	indexed_models.push(primitives::unit_sphere());
@@ -118,7 +139,49 @@ pub fn default_models()->model::IndexedModelInstances{
 	}
 }
 
-fn main(){
-	let context=setup::setup(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str());
-	context.start();//creates and runs a window context
+impl GlobalState {
+	fn init() -> Self {
+		//wee
+		let user_settings=settings::read_user_settings();
+
+		let mut graphics=GraphicsState::new();
+
+		graphics.load_user_settings(&user_settings);
+
+		//how to multithread
+
+		//1. build
+		physics.generate_models(&indexed_model_instances);
+
+		//2. move
+		let physics_thread=physics.into_worker();
+
+		//3. forget
+
+		let mut state=GlobalState{
+			start_time:Instant::now(),
+			manual_mouse_lock:false,
+			mouse:physics::MouseState::default(),
+			user_settings,
+			graphics,
+			physics_thread,
+		};
+		state.generate_model_graphics(&device,&queue,indexed_model_instances);
+
+		let args:Vec<String>=std::env::args().collect();
+		if args.len()==2{
+			let indexed_model_instances=load_file(std::path::PathBuf::from(&args[1]));
+			state.render_thread=RenderThread::new(user_settings,indexed_model_instances);
+		}
+
+		return state;
+	}
+}
+
+fn main(){
+	let title=format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")).as_str();
+	let context=graphics_context::setup(title);
+	let global_state=GlobalState::init();//new
+	global_state.replace_models(&context,default_models());
+	context.start(global_state);
 }

src/physics.rs

@@ -31,12 +31,9 @@ pub enum PhysicsInputInstruction {
 	SetZoom(bool),
 	Reset,
 	Idle,
-		//Idle: there were no input events, but the simulation is safe to advance to this timestep
-		//for interpolation / networking / playback reasons, most playback heads will always want
-		//to be 1 instruction ahead to generate the next state for interpolation.
 }
 
-#[derive(Clone,Hash,Default)]
+#[derive(Clone,Hash)]
 pub struct Body {
 	position: Planar64Vec3,//I64 where 2^32 = 1 u
 	velocity: Planar64Vec3,//I64 where 2^32 = 1 u/s
@@ -244,19 +241,6 @@ impl PhysicsCamera {
 	}
 }
 
-impl std::default::Default for PhysicsCamera{
-	fn default()->Self{
-		Self{
-			offset:Planar64Vec3::ZERO,//TODO: delete this from PhysicsCamera, it should be GraphicsCamera only
-			sensitivity:Ratio64Vec2::ONE*200_000,
-			mouse:MouseState::default(),//t=0 does not cause divide by zero because it's immediately replaced
-			clamped_mouse_pos:glam::IVec2::ZERO,
-			angle_pitch_lower_limit:-Angle32::FRAC_PI_2,
-			angle_pitch_upper_limit:Angle32::FRAC_PI_2,
-		}
-	}
-}
-
 pub struct GameMechanicsState{
 	pub stage_id:u32,
 	//jump_counts:HashMap<u32,u32>,
@@ -543,14 +527,14 @@ pub struct PhysicsState{
 	//This is not the same as Reset which teleports you to Spawn0
 	spawn_point:Planar64Vec3,
 }
-#[derive(Clone,Default)]
+#[derive(Clone)]
 pub struct PhysicsOutputState{
 	camera:PhysicsCamera,
 	body:Body,
 }
 impl PhysicsOutputState{
-	pub fn extrapolate(&self,mouse_pos:glam::IVec2,time:Time)->(glam::Vec3,glam::Vec2){
-		((self.body.extrapolated_position(time)+self.camera.offset).into(),self.camera.simulate_move_angles(mouse_pos))
+	pub fn adjust_mouse(&self,mouse:&MouseState)->(glam::Vec3,glam::Vec2){
+		((self.body.extrapolated_position(mouse.time)+self.camera.offset).into(),self.camera.simulate_move_angles(mouse.pos))
 	}
 }
 
@@ -734,7 +718,6 @@ impl PhysicsState {
 		self.models.clear();
 		self.modes.clear();
 		self.touching.clear();
-		self.bvh=crate::bvh::BvhNode::default();
 	}
 
 	pub fn output(&self)->PhysicsOutputState{

src/physics_worker.rs

@@ -1,133 +0,0 @@
-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/render_thread.rs

@@ -0,0 +1,129 @@
+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,
+	Render,
+		//Idle: there were no input events, but the simulation is safe to advance to this timestep
+		//for interpolation / networking / playback reasons, most playback heads will always want
+		//to be 1 instruction ahead to generate the next state for interpolation.
+}
+
+pub struct RenderState{
+	physics:crate::physics::PhysicsState,
+	graphics:crate::graphics::GraphicsState,
+}
+impl RenderState{
+	pub fn new(user_settings:&crate::settings::UserSettings,indexed_model_instances:crate::model::IndexedModelInstances){
+
+		let mut physics=crate::physics::PhysicsState::default();
+		physics.spawn(indexed_model_instances.spawn_point);
+		physics.load_user_settings(user_settings);
+		physics.generate_models(&indexed_model_instances);
+
+		let mut graphics=Self::new_graphics_state();
+		graphics.load_user_settings(user_settings);
+		graphics.generate_models(indexed_model_instances);
+		//manual reset
+	}
+	pub fn into_worker(mut self)->crate::worker::CNWorker<TimedInstruction<InputInstruction>>{
+		let mut mouse_blocking=true;
+		let mut last_mouse_time=self.physics.next_mouse.time;
+		let mut timeline=std::collections::VecDeque::new();
+		crate::worker::CNWorker::new(move |ins:TimedInstruction<InputInstruction>|{
+			let mut render=false;
+			if if let Some(phys_input)=match ins.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:self.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),
+				InputInstruction::Render=>{render=true;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-self.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:self.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(){
+					self.physics.run(instruction.time);
+					self.physics.process_instruction(TimedInstruction{
+						time:instruction.time,
+						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
+					});
+				}
+			}
+			if render{
+				self.graphics.render();
+			}
+		})
+	}
+}

src/settings.rs

@@ -1,14 +1,11 @@
 use crate::integer::{Ratio64,Ratio64Vec2};
-#[derive(Clone)]
 struct Ratio{
 	ratio:f64,
 }
-#[derive(Clone)]
 enum DerivedFov{
 	FromScreenAspect,
 	FromAspect(Ratio),
 }
-#[derive(Clone)]
 enum Fov{
 	Exactly{x:f64,y:f64},
 	SpecifyXDeriveY{x:f64,y:DerivedFov},
@@ -19,11 +16,9 @@ impl Default for Fov{
 		Fov::SpecifyYDeriveX{x:DerivedFov::FromScreenAspect,y:1.0}
 	}
 }
-#[derive(Clone)]
 enum DerivedSensitivity{
 	FromRatio(Ratio64),
 }
-#[derive(Clone)]
 enum Sensitivity{
 	Exactly{x:Ratio64,y:Ratio64},
 	SpecifyXDeriveY{x:Ratio64,y:DerivedSensitivity},
@@ -35,7 +30,7 @@ impl Default for Sensitivity{
 	}
 }
 
-#[derive(Default,Clone)]
+#[derive(Default)]
 pub struct UserSettings{
 	fov:Fov,
 	sensitivity:Sensitivity,

src/window.rs

@@ -1,68 +1,50 @@
-use crate::instruction::TimedInstruction;
-use crate::physics_worker::InputInstruction;
-
-pub enum WindowInstruction{
-	Resize(winit::dpi::PhysicalSize<u32>),
-	WindowEvent(winit::event::WindowEvent),
-	DeviceEvent(winit::event::DeviceEvent),
-	RequestRedraw,
-	Render,
+pub struct WindowState{
+	//ok
 }
+impl WindowState{
+	fn resize(&mut self);
+	fn render(&self);
 
-//holds thread handles to dispatch to
-struct WindowContext<'a>{
-	manual_mouse_lock:bool,
-	mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
-	screen_size:glam::UVec2,
-	user_settings:crate::settings::UserSettings,
-	window:winit::window::Window,
-	physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
-}
-
-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:crate::integer::Time,event: winit::event::WindowEvent) {
+	fn update(&mut self, window: &winit::window::Window, event: winit::event::WindowEvent) {
+		let time=integer::Time::from_nanos(self.start_time.elapsed().as_nanos() as i64);
 		match event {
 			winit::event::WindowEvent::DroppedFile(path)=>{
-				//blocking because it's simpler...
-				if let Some(indexed_model_instances)=crate::load_file(path){
-					self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ClearModels}).unwrap();
-					self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::GenerateModels(indexed_model_instances)}).unwrap();
-				}
+				std::thread::spawn(move ||{
+					let indexed_model_instances=load_file(path);
+					self.render_thread.send(Instruction::Die(indexed_model_instances));
+				});
 			},
 			winit::event::WindowEvent::Focused(state)=>{
 				//pause unpause
 				//recalculate pressed keys on focus
 			},
-			winit::event::WindowEvent::KeyboardInput{
-				event:winit::event::KeyEvent{state,logical_key,repeat:false,..},
+			winit::event::WindowEvent::KeyboardInput {
+				input:winit::event::KeyboardInput{state, virtual_keycode,..},
 				..
 			}=>{
-				let s=match state{
-					winit::event::ElementState::Pressed=>true,
-					winit::event::ElementState::Released=>false,
+				let s=match state {
+					winit::event::ElementState::Pressed => true,
+					winit::event::ElementState::Released => false,
 				};
-				match logical_key{
-					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab)=>{
+				match virtual_keycode{
+					Some(winit::event::VirtualKeyCode::Tab)=>{
 						if s{
 							self.manual_mouse_lock=false;
-							match self.window.set_cursor_position(self.get_middle_of_screen()){
+							match window.set_cursor_position(winit::dpi::PhysicalPosition::new(self.graphics.camera.screen_size.x as f32/2.0, self.graphics.camera.screen_size.y as f32/2.0)){
 								Ok(())=>(),
 								Err(e)=>println!("Could not set cursor position: {:?}",e),
 							}
-							match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
 								Ok(())=>(),
 								Err(e)=>println!("Could not release cursor: {:?}",e),
 							}
 						}else{
 							//if cursor is outside window don't lock but apparently there's no get pos function
 							//let pos=window.get_cursor_pos();
-							match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
+							match window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
 								Ok(())=>(),
 								Err(_)=>{
-									match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+									match window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
 										Ok(())=>(),
 										Err(e)=>{
 											self.manual_mouse_lock=true;
@@ -72,62 +54,62 @@ impl WindowContext<'_>{
 								}
 							}
 						}
-						self.window.set_cursor_visible(s);
+						window.set_cursor_visible(s);
 					},
-					winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11)=>{
+					Some(winit::event::VirtualKeyCode::F11)=>{
 						if s{
-							if self.window.fullscreen().is_some(){
-								self.window.set_fullscreen(None);
+							if window.fullscreen().is_some(){
+								window.set_fullscreen(None);
 							}else{
-								self.window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
+								window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
 							}
 						}
 					},
-					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape)=>{
+					Some(winit::event::VirtualKeyCode::Escape)=>{
 						if s{
 							self.manual_mouse_lock=false;
-							match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
 								Ok(())=>(),
 								Err(e)=>println!("Could not release cursor: {:?}",e),
 							}
-							self.window.set_cursor_visible(true);
+							window.set_cursor_visible(true);
 						}
 					},
-					keycode=>{
-						if let Some(input_instruction)=match keycode{
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
-							winit::keyboard::Key::Character(key)=>match key.as_str(){
-								"w"=>Some(InputInstruction::MoveForward(s)),
-								"a"=>Some(InputInstruction::MoveLeft(s)),
-								"s"=>Some(InputInstruction::MoveBack(s)),
-								"d"=>Some(InputInstruction::MoveRight(s)),
-								"e"=>Some(InputInstruction::MoveUp(s)),
-								"q"=>Some(InputInstruction::MoveDown(s)),
-								"z"=>Some(InputInstruction::Zoom(s)),
-								"r"=>if s{Some(InputInstruction::Reset)}else{None},
-								_=>None,
-							},
-							_=>None,
+					Some(keycode)=>{
+						if let Some(input_instruction)=match keycode {
+							winit::event::VirtualKeyCode::W => Some(InputInstruction::MoveForward(s)),
+							winit::event::VirtualKeyCode::A => Some(InputInstruction::MoveLeft(s)),
+							winit::event::VirtualKeyCode::S => Some(InputInstruction::MoveBack(s)),
+							winit::event::VirtualKeyCode::D => Some(InputInstruction::MoveRight(s)),
+							winit::event::VirtualKeyCode::E => Some(InputInstruction::MoveUp(s)),
+							winit::event::VirtualKeyCode::Q => Some(InputInstruction::MoveDown(s)),
+							winit::event::VirtualKeyCode::Space => Some(InputInstruction::Jump(s)),
+							winit::event::VirtualKeyCode::Z => Some(InputInstruction::Zoom(s)),
+							winit::event::VirtualKeyCode::R => if s{Some(InputInstruction::Reset)}else{None},
+							_ => None,
 						}{
 							self.physics_thread.send(TimedInstruction{
 								time,
-								instruction:crate::physics_worker::Instruction::Input(input_instruction),
+								instruction:input_instruction,
 							}).unwrap();
 						}
 					},
+					_=>(),
 				}
 			},
 			_=>(),
 		}
 	}
 
-	fn device_event(&mut self,time:crate::integer::Time,event: winit::event::DeviceEvent) {
+	fn device_event(&mut self, window: &winit::window::Window, event: winit::event::DeviceEvent) {
+		//there's no way this is the best way get a timestamp.
+		let time=integer::Time::from_nanos(self.start_time.elapsed().as_nanos() as i64);
 		match event {
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
 			} => {
 				if self.manual_mouse_lock{
-					match self.window.set_cursor_position(self.get_middle_of_screen()){
+					match window.set_cursor_position(winit::dpi::PhysicalPosition::new(self.graphics.camera.screen_size.x as f32/2.0, self.graphics.camera.screen_size.y as f32/2.0)){
 						Ok(())=>(),
 						Err(e)=>println!("Could not set cursor position: {:?}",e),
 					}
@@ -139,7 +121,7 @@ impl WindowContext<'_>{
 				self.mouse.pos+=delta;
 				self.physics_thread.send(TimedInstruction{
 					time,
-					instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
+					instruction:InputInstruction::MoveMouse(self.mouse.pos),
 				}).unwrap();
 			},
 			winit::event::DeviceEvent::MouseWheel {
@@ -149,95 +131,22 @@ impl WindowContext<'_>{
 				if false{//self.physics.style.use_scroll{
 					self.physics_thread.send(TimedInstruction{
 						time,
-						instruction:crate::physics_worker::Instruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
+						instruction:InputInstruction::Jump(true),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
 					}).unwrap();
 				}
 			}
 			_=>(),
 		}
 	}
-}
 
-pub struct WindowContextSetup{
-	user_settings:crate::settings::UserSettings,
-	window:winit::window::Window,
-	physics:crate::physics::PhysicsState,
-	graphics:crate::graphics::GraphicsState,
-}
-
-impl WindowContextSetup{
-	pub fn new(context:&crate::setup::SetupContext,window:winit::window::Window)->Self{
-		//wee
-		let user_settings=crate::settings::read_user_settings();
-
-		let args:Vec<String>=std::env::args().collect();
-		let indexed_model_instances=if args.len()==2{
-			crate::load_file(std::path::PathBuf::from(&args[1]))
-		}else{
-			None
-		}.unwrap_or(crate::default_models());
-
-		let mut physics=crate::physics::PhysicsState::default();
-		physics.load_user_settings(&user_settings);
-		physics.generate_models(&indexed_model_instances);
-		physics.spawn(indexed_model_instances.spawn_point);
-
-		let mut graphics=crate::graphics::GraphicsState::new(&context.device,&context.queue,&context.config);
-		graphics.load_user_settings(&user_settings);
-		graphics.generate_models(&context.device,&context.queue,indexed_model_instances);
-
-		Self{
-			user_settings,
-			window,
-			graphics,
-			physics,
+	pub fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
+		let mut builder = winit::window::WindowBuilder::new();
+		builder = builder.with_title(title);
+		#[cfg(windows_OFF)] // TODO
+		{
+			use winit::platform::windows::WindowBuilderExtWindows;
+			builder = builder.with_no_redirection_bitmap(true);
 		}
-	}
-
-	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{
-			manual_mouse_lock:false,
-			mouse:crate::physics::MouseState::default(),
-			//make sure to update this!!!!!
-			screen_size,
-			user_settings:self.user_settings,
-			window:self.window,
-			physics_thread:crate::physics_worker::new(self.physics,graphics_thread),
-		}
-	}
-
-	pub fn into_worker<'a>(self,setup_context:crate::setup::SetupContext)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
-		let mut window_context=self.into_context(setup_context);
-		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
-			match ins.instruction{
-				WindowInstruction::RequestRedraw=>{
-					window_context.window.request_redraw();
-				}
-				WindowInstruction::WindowEvent(window_event)=>{
-					window_context.window_event(ins.time,window_event);
-				},
-				WindowInstruction::DeviceEvent(device_event)=>{
-					window_context.device_event(ins.time,device_event);
-				},
-				WindowInstruction::Resize(size)=>{
-					window_context.physics_thread.send(
-						TimedInstruction{
-							time:ins.time,
-							instruction:crate::physics_worker::Instruction::Resize(size,window_context.user_settings.clone())
-						}
-					).unwrap();
-				}
-				WindowInstruction::Render=>{
-					window_context.physics_thread.send(
-						TimedInstruction{
-							time:ins.time,
-							instruction:crate::physics_worker::Instruction::Render
-						}
-					).unwrap();
-				}
-			}
-		})
+		builder.build(event_loop)
 	}
 }

src/worker.rs

@@ -104,15 +104,17 @@ QN = WorkerDescription{
 }
 */
 //None Output Worker does all its work internally from the perspective of the work submitter
-pub struct QNWorker<'a,Task:Send>{
+pub struct QNWorker<Task:Send> {
 	sender: mpsc::Sender<Task>,
-	handle:thread::ScopedJoinHandle<'a,()>,
 }
 
-impl<'a,Task:Send+'a> QNWorker<'a,Task>{
-	pub fn new<F:FnMut(Task)+Send+'a>(scope:&'a thread::Scope<'a,'_>,mut f:F)->QNWorker<'a,Task>{
+impl<Task:Send+'static> QNWorker<Task>{
+	pub fn new<F:FnMut(Task)+Send+'static>(mut f:F)->Self{
 		let (sender,receiver)=mpsc::channel::<Task>();
-		let handle=scope.spawn(move ||{
+		let ret=Self {
+			sender,
+		};
+		thread::spawn(move ||{
 			loop {
 				match receiver.recv() {
 					Ok(task)=>f(task),
@@ -123,10 +125,7 @@ impl<'a,Task:Send+'a> QNWorker<'a,Task>{
 				}
 			}
 		});
-		Self{
-			sender,
-			handle,
-		}
+		ret
 	}
 	pub fn send(&self,task:Task)->Result<(),mpsc::SendError<Task>>{
 		self.sender.send(task)
@@ -140,36 +139,104 @@ IN = WorkerDescription{
 }
 */
 //Inputs are dropped if the worker is busy
-pub struct INWorker<'a,Task:Send>{
-	sender: mpsc::SyncSender<Task>,
-	handle:thread::ScopedJoinHandle<'a,()>,
+pub struct INWorker<Task:Clone>{
+	input:Arc<(Mutex<Task>,Condvar)>,
 }
 
-impl<'a,Task:Send+'a> INWorker<'a,Task>{
-	pub fn new<F:FnMut(Task)+Send+'a>(scope:&'a thread::Scope<'a,'_>,mut f:F)->INWorker<'a,Task>{
-		let (sender,receiver)=mpsc::sync_channel::<Task>(1);
-		let handle=scope.spawn(move ||{
+impl<Task:Clone+Send+'static> INWorker<Task>{
+	pub fn new<F:FnMut(Task)+Send+'static>(task:Task,mut f:F)->Self{
+		let ret=Self {
+			input:Arc::new((Mutex::new(task),Condvar::new())),
+		};
+		let input=ret.input.clone();
+		thread::spawn(move ||{
 			loop {
-				match receiver.recv() {
-					Ok(task)=>f(task),
+				input.1.wait(&mut input.0.lock());
+				f(input.0.lock().clone());
+			}
+		});
+		ret
+	}
+	pub fn send(&self,task:Task){
+		*self.input.0.lock()=task;
+        self.input.1.notify_one();
+	}
+}
+
+//worker pools work by cloning a mpsc and passing it into the thread, the thread sends its results through that
+//worker pools have a master thread that manages the pool so that the work submission thread does not need to implement async
+
+pub struct QQWorkerPool<Task:Send,Value:Send>{
+	sender:mpsc::Sender<Task>,
+	queue:Arc<Mutex<std::collections::VecDeque<Value>>>,
+}
+
+impl<Task:Send+'static,Value:Send+'static> QQWorkerPool<Task,Value>{
+	pub fn new<F:Fn(Task)->Value+Send+'static>(pool_size:usize,f:F)->Self{
+		let (task_sender,task_receiver)=mpsc::channel::<Task>();
+		let (value_sender,value_receiver)=mpsc::channel::<Value>();
+		let ret=Self{
+			sender:task_sender,
+			queue:Arc::new(Mutex::new(std::collections::VecDeque::new())),
+		};
+		let mut queue_collect=ret.queue.clone();
+		let mut worker_senders=Vec::with_capacity(pool_size);
+		let mut active_workers_collect=Arc::new(Mutex::new(0usize));
+		let mut active_workers_dispatch=active_workers_collect.clone();
+		let mut condvar_collect=Arc::new(Condvar::new());
+		let mut condvar_dispatch=condvar_collect.clone();
+		//task dispatch thread
+		thread::spawn(move ||{
+			loop{
+				//block if no workers are available, value collection thread will notify
+				let n=*active_workers_dispatch.lock();
+				if n==pool_size{
+					//wait for notifiy
+					condvar_dispatch.wait(&mut active_workers_dispatch.lock());
+				}
+				match task_receiver.recv(){
+					Ok(task)=>{
+						*active_workers_dispatch.lock()+=1;
+						//workers are never full here
+						//else if workers busy: spawn a new worker
+						//else: send task to an available worker
+					}
 					Err(_)=>{
-						println!("Worker stopping.",);
+						println!("Dispatch stopping.",);
 						break;
 					}
 				}
 			}
 		});
-		Self{
-			sender,
-			handle,
-		}
+		//value collection thread (bad idea, put this logic in each thread)
+		thread::spawn(move ||{
+			loop{
+				match value_receiver.recv(){
+					Ok(value)=>{
+						//maybe I can be smart with this as a signal that a worker finished a task
+						let n=*active_workers_collect.lock();
+						*active_workers_collect.lock()-=1;
+						if n==pool_size{
+							condvar_collect.notify_one();
+						}
+						(*queue_collect.lock()).push_front(value);
+					}
+					Err(_)=>{
+						println!("Collection stopping.",);
+						break;
+					}
+				}
+			}
+		});
+		ret
 	}
-	//blocking!
-	pub fn blocking_send(&self,task:Task)->Result<(), mpsc::SendError<Task>>{
+
+	pub fn send(&self,task:Task)->Result<(),mpsc::SendError<Task>>{
 		self.sender.send(task)
 	}
-	pub fn send(&self,task:Task)->Result<(), mpsc::TrySendError<Task>>{
-		self.sender.try_send(task)
+
+	pub fn get(&self)->Option<Value>{
+		(*self.queue.lock()).pop_back()
 	}
 }