schedule frames at a fixed interval

Cargo.toml

@@ -6,14 +6,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-executor = "1.5.1"
 bytemuck = { version = "1.13.1", features = ["derive"] }
 configparser = "3.0.2"
 ddsfile = "0.5.1"
-env_logger = "0.10.0"
 glam = "0.24.1"
 lazy-regex = "3.0.2"
-log = "0.4.20"
 obj = "0.10.2"
 parking_lot = "0.12.1"
 pollster = "0.3.0"
@@ -21,8 +18,8 @@ rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
-wgpu = "0.17.0"
-winit = "0.28.6"
+wgpu = "0.18.0"
+winit = { version = "0.29.2", features = ["rwh_05"] }
 
 #[profile.release]
 #lto = true

src/bvh.rs

@@ -9,22 +9,34 @@ use crate::aabb::Aabb;
 //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{
-	children:Vec<Self>,
-	models:Vec<usize>,
+	content:BvhNodeContent,
 	aabb:Aabb,
 }
 
 impl BvhNode{
 	pub fn the_tester<F:FnMut(usize)>(&self,aabb:&Aabb,f:&mut F){
-		for &model in &self.models{
-			f(model);
-		}
-		for child in &self.children{
-			if aabb.intersects(&child.aabb){
-				child.the_tester(aabb,f);
-			}
+		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);
+				}
+			},
 		}
 	}
 }
@@ -37,10 +49,15 @@ fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
 	let n=boxen.len();
 	if n<20{
 		let mut aabb=Aabb::default();
-		let models=boxen.into_iter().map(|b|{aabb.join(&b.1);b.0}).collect();
+		let nodes=boxen.into_iter().map(|b|{
+			aabb.join(&b.1);
+			BvhNode{
+				content:BvhNodeContent::Leaf(b.0),
+				aabb:b.1,
+			}
+		}).collect();
 		BvhNode{
-			children:Vec::new(),
-			models,
+			content:BvhNodeContent::Branch(nodes),
 			aabb,
 		}
 	}else{
@@ -99,8 +116,7 @@ fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
 			node
 		}).collect();
 		BvhNode{
-			children,
-			models:Vec::new(),
+			content:BvhNodeContent::Branch(children),
 			aabb,
 		}
 	}

src/compat_worker.rs

@@ -0,0 +1,21 @@
+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)+Send+'a>,
+}
+
+impl<'a,Task> CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+Send+'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/framework.rs

@@ -1,516 +0,0 @@
-use std::future::Future;
-#[cfg(target_arch = "wasm32")]
-use std::str::FromStr;
-#[cfg(target_arch = "wasm32")]
-use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
-use winit::{
-	event::{self, WindowEvent, DeviceEvent},
-	event_loop::{ControlFlow, EventLoop},
-};
-
-#[allow(dead_code)]
-pub fn cast_slice<T>(data: &[T]) -> &[u8] {
-	use std::{mem::size_of, slice::from_raw_parts};
-
-	unsafe { from_raw_parts(data.as_ptr() as *const u8, data.len() * size_of::<T>()) }
-}
-
-#[allow(dead_code)]
-pub enum ShaderStage {
-	Vertex,
-	Fragment,
-	Compute,
-}
-
-pub trait Example: 'static + Sized {
-	fn optional_features() -> wgpu::Features {
-		wgpu::Features::empty()
-	}
-	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,
-			..wgpu::DownlevelCapabilities::default()
-		}
-	}
-	fn required_limits() -> wgpu::Limits {
-		wgpu::Limits::downlevel_webgl2_defaults() // These downlevel limits will allow the code to run on all possible hardware
-	}
-	fn init(
-		config: &wgpu::SurfaceConfiguration,
-		adapter: &wgpu::Adapter,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-	) -> Self;
-	fn resize(
-		&mut self,
-		config: &wgpu::SurfaceConfiguration,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-	);
-	fn update(&mut self, window: &winit::window::Window, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent);
-	fn device_event(&mut self, window: &winit::window::Window, event: DeviceEvent);
-	fn load_file(&mut self, path:std::path::PathBuf, device: &wgpu::Device, queue: &wgpu::Queue);
-	fn render(
-		&mut self,
-		view: &wgpu::TextureView,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-		spawner: &Spawner,
-	);
-}
-
-struct Setup {
-	window: winit::window::Window,
-	event_loop: EventLoop<()>,
-	instance: wgpu::Instance,
-	size: winit::dpi::PhysicalSize<u32>,
-	surface: wgpu::Surface,
-	adapter: wgpu::Adapter,
-	device: wgpu::Device,
-	queue: wgpu::Queue,
-	#[cfg(target_arch = "wasm32")]
-	offscreen_canvas_setup: Option<OffscreenCanvasSetup>,
-}
-
-#[cfg(target_arch = "wasm32")]
-struct OffscreenCanvasSetup {
-	offscreen_canvas: OffscreenCanvas,
-	bitmap_renderer: ImageBitmapRenderingContext,
-}
-
-async fn setup<E: Example>(title: &str) -> Setup {
-	#[cfg(not(target_arch = "wasm32"))]
-	{
-		env_logger::init();
-	};
-
-	let event_loop = EventLoop::new();
-	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);
-	}
-	let window = builder.build(&event_loop).unwrap();
-
-	#[cfg(target_arch = "wasm32")]
-	{
-		use winit::platform::web::WindowExtWebSys;
-		let query_string = web_sys::window().unwrap().location().search().unwrap();
-		let level: log::Level = parse_url_query_string(&query_string, "RUST_LOG")
-			.and_then(|x| x.parse().ok())
-			.unwrap_or(log::Level::Error);
-		console_log::init_with_level(level).expect("could not initialize logger");
-		std::panic::set_hook(Box::new(console_error_panic_hook::hook));
-		// On wasm, append the canvas to the document body
-		web_sys::window()
-			.and_then(|win| win.document())
-			.and_then(|doc| doc.body())
-			.and_then(|body| {
-				body.append_child(&web_sys::Element::from(window.canvas()))
-					.ok()
-			})
-			.expect("couldn't append canvas to document body");
-	}
-
-	#[cfg(target_arch = "wasm32")]
-	let mut offscreen_canvas_setup: Option<OffscreenCanvasSetup> = None;
-	#[cfg(target_arch = "wasm32")]
-	{
-		use wasm_bindgen::JsCast;
-		use winit::platform::web::WindowExtWebSys;
-
-		let query_string = web_sys::window().unwrap().location().search().unwrap();
-		if let Some(offscreen_canvas_param) =
-			parse_url_query_string(&query_string, "offscreen_canvas")
-		{
-			if FromStr::from_str(offscreen_canvas_param) == Ok(true) {
-				log::info!("Creating OffscreenCanvasSetup");
-
-				let offscreen_canvas =
-					OffscreenCanvas::new(1024, 768).expect("couldn't create OffscreenCanvas");
-
-				let bitmap_renderer = window
-					.canvas()
-					.get_context("bitmaprenderer")
-					.expect("couldn't create ImageBitmapRenderingContext (Result)")
-					.expect("couldn't create ImageBitmapRenderingContext (Option)")
-					.dyn_into::<ImageBitmapRenderingContext>()
-					.expect("couldn't convert into ImageBitmapRenderingContext");
-
-				offscreen_canvas_setup = Some(OffscreenCanvasSetup {
-					offscreen_canvas,
-					bitmap_renderer,
-				})
-			}
-		}
-	};
-
-	log::info!("Initializing the surface...");
-
-	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();
-
-	let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-		backends,
-		dx12_shader_compiler,
-	});
-	let (size, surface) = unsafe {
-		let size = window.inner_size();
-
-		#[cfg(any(not(target_arch = "wasm32"), target_os = "emscripten"))]
-		let surface = instance.create_surface(&window).unwrap();
-		#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
-		let surface = {
-			if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
-				log::info!("Creating surface from OffscreenCanvas");
-				instance.create_surface_from_offscreen_canvas(
-					offscreen_canvas_setup.offscreen_canvas.clone(),
-				)
-			} else {
-				instance.create_surface(&window)
-			}
-		}
-		.unwrap();
-
-		(size, surface)
-	};
-
-	let adapter;
-
-	let optional_features = E::optional_features();
-	let required_features = E::required_features();
-
-	//no helper function smh gotta write it myself
-	let adapters = instance.enumerate_adapters(backends);
-
-	let mut chosen_adapter = None;
-	let mut chosen_adapter_score=0;
-	for adapter in adapters {
-		if !adapter.is_surface_supported(&surface) {
-			continue;
-		}
-
-		let score=match adapter.get_info().device_type{
-			wgpu::DeviceType::IntegratedGpu=>3,
-			wgpu::DeviceType::DiscreteGpu=>4,
-			wgpu::DeviceType::VirtualGpu=>2,
-			wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
-		};
-
-		let adapter_features = adapter.features();
-		if chosen_adapter_score<score&&adapter_features.contains(required_features) {
-			chosen_adapter_score=score;
-			chosen_adapter=Some(adapter);
-		}
-	}
-
-	if let Some(maybe_chosen_adapter) = chosen_adapter{
-		adapter=maybe_chosen_adapter;
-	}else{
-		panic!("No suitable GPU adapters found on the system!");
-	}
-
-	#[cfg(not(target_arch = "wasm32"))]
-	{
-		let adapter_info = adapter.get_info();
-		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
-	}
-
-	let required_downlevel_capabilities = E::required_downlevel_capabilities();
-	let downlevel_capabilities = adapter.get_downlevel_capabilities();
-	assert!(
-		downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
-		"Adapter does not support the minimum shader model required to run this example: {:?}",
-		required_downlevel_capabilities.shader_model
-	);
-	assert!(
-		downlevel_capabilities
-			.flags
-			.contains(required_downlevel_capabilities.flags),
-		"Adapter does not support the downlevel capabilities required to run this example: {:?}",
-		required_downlevel_capabilities.flags - downlevel_capabilities.flags
-	);
-
-	// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
-	let needed_limits = E::required_limits().using_resolution(adapter.limits());
-
-	let trace_dir = std::env::var("WGPU_TRACE");
-	let (device, queue) = adapter
-		.request_device(
-			&wgpu::DeviceDescriptor {
-				label: None,
-				features: (optional_features & adapter.features()) | required_features,
-				limits: needed_limits,
-			},
-			trace_dir.ok().as_ref().map(std::path::Path::new),
-		)
-		.await
-		.expect("Unable to find a suitable GPU adapter!");
-
-	Setup {
-		window,
-		event_loop,
-		instance,
-		size,
-		surface,
-		adapter,
-		device,
-		queue,
-		#[cfg(target_arch = "wasm32")]
-		offscreen_canvas_setup,
-	}
-}
-
-fn start<E: Example>(
-	#[cfg(not(target_arch = "wasm32"))] Setup {
-		window,
-		event_loop,
-		instance,
-		size,
-		surface,
-		adapter,
-		device,
-		queue,
-	}: Setup,
-	#[cfg(target_arch = "wasm32")] Setup {
-		window,
-		event_loop,
-		instance,
-		size,
-		surface,
-		adapter,
-		device,
-		queue,
-		offscreen_canvas_setup,
-	}: Setup,
-) {
-	let spawner = Spawner::new();
-	let mut config = surface
-		.get_default_config(&adapter, size.width, size.height)
-		.expect("Surface isn't supported by the adapter.");
-	let surface_view_format = config.format.add_srgb_suffix();
-	config.view_formats.push(surface_view_format);
-	surface.configure(&device, &config);
-
-	log::info!("Initializing the example...");
-	let mut example = E::init(&config, &adapter, &device, &queue);
-
-	log::info!("Entering render loop...");
-	event_loop.run(move |event, _, control_flow| {
-		let _ = (&instance, &adapter); // force ownership by the closure
-		*control_flow = if cfg!(feature = "metal-auto-capture") {
-			ControlFlow::Exit
-		} else {
-			ControlFlow::Poll
-		};
-		match event {
-			event::Event::RedrawEventsCleared => {
-				#[cfg(not(target_arch = "wasm32"))]
-				spawner.run_until_stalled();
-
-				window.request_redraw();
-			}
-			event::Event::WindowEvent {
-				event:
-					WindowEvent::Resized(size)
-					| WindowEvent::ScaleFactorChanged {
-						new_inner_size: &mut size,
-						..
-					},
-				..
-			} => {
-				// Once winit is fixed, the detection conditions here can be removed.
-				// https://github.com/rust-windowing/winit/issues/2876
-				let max_dimension = adapter.limits().max_texture_dimension_2d;
-				if size.width > max_dimension || size.height > max_dimension {
-					log::warn!(
-						"The resizing size {:?} exceeds the limit of {}.",
-						size,
-						max_dimension
-					);
-				} else {
-					log::info!("Resizing to {:?}", size);
-					config.width = size.width.max(1);
-					config.height = size.height.max(1);
-					example.resize(&config, &device, &queue);
-					surface.configure(&device, &config);
-				}
-			}
-			event::Event::WindowEvent { event, .. } => match event {
-				WindowEvent::KeyboardInput {
-					input:
-						event::KeyboardInput {
-							virtual_keycode: Some(event::VirtualKeyCode::Escape),
-							state: event::ElementState::Pressed,
-							..
-						},
-					..
-				}
-				| WindowEvent::CloseRequested => {
-					*control_flow = ControlFlow::Exit;
-				}
-				#[cfg(not(target_arch = "wasm32"))]
-				WindowEvent::KeyboardInput {
-					input:
-						event::KeyboardInput {
-							virtual_keycode: Some(event::VirtualKeyCode::Scroll),
-							state: event::ElementState::Pressed,
-							..
-						},
-					..
-				} => {
-					println!("{:#?}", instance.generate_report());
-				}
-				_ => {
-					example.update(&window,&device,&queue,event);
-				}
-			},
-			event::Event::DeviceEvent {
-				event,
-				..
-			} => {
-				example.device_event(&window,event);
-			},
-			event::Event::RedrawRequested(_) => {
-
-				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(surface_view_format),
-					..wgpu::TextureViewDescriptor::default()
-				});
-
-				example.render(&view, &device, &queue, &spawner);
-
-				frame.present();
-
-				#[cfg(target_arch = "wasm32")]
-				{
-					if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
-						let image_bitmap = offscreen_canvas_setup
-							.offscreen_canvas
-							.transfer_to_image_bitmap()
-							.expect("couldn't transfer offscreen canvas to image bitmap.");
-						offscreen_canvas_setup
-							.bitmap_renderer
-							.transfer_from_image_bitmap(&image_bitmap);
-
-						log::info!("Transferring OffscreenCanvas to ImageBitmapRenderer");
-					}
-				}
-			}
-			_ => {}
-		}
-	});
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub struct Spawner<'a> {
-	executor: async_executor::LocalExecutor<'a>,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl<'a> Spawner<'a> {
-	fn new() -> Self {
-		Self {
-			executor: async_executor::LocalExecutor::new(),
-		}
-	}
-
-	#[allow(dead_code)]
-	pub fn spawn_local(&self, future: impl Future<Output = ()> + 'a) {
-		self.executor.spawn(future).detach();
-	}
-
-	fn run_until_stalled(&self) {
-		while self.executor.try_tick() {}
-	}
-}
-
-#[cfg(target_arch = "wasm32")]
-pub struct Spawner {}
-
-#[cfg(target_arch = "wasm32")]
-impl Spawner {
-	fn new() -> Self {
-		Self {}
-	}
-
-	#[allow(dead_code)]
-	pub fn spawn_local(&self, future: impl Future<Output = ()> + 'static) {
-		wasm_bindgen_futures::spawn_local(future);
-	}
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub fn run<E: Example>(title: &str) {
-	let setup = pollster::block_on(setup::<E>(title));
-	start::<E>(setup);
-}
-
-#[cfg(target_arch = "wasm32")]
-pub fn run<E: Example>(title: &str) {
-	use wasm_bindgen::prelude::*;
-
-	let title = title.to_owned();
-	wasm_bindgen_futures::spawn_local(async move {
-		let setup = setup::<E>(&title).await;
-		let start_closure = Closure::once_into_js(move || start::<E>(setup));
-
-		// make sure to handle JS exceptions thrown inside start.
-		// Otherwise wasm_bindgen_futures Queue would break and never handle any tasks again.
-		// This is required, because winit uses JS exception for control flow to escape from `run`.
-		if let Err(error) = call_catch(&start_closure) {
-			let is_control_flow_exception = error.dyn_ref::<js_sys::Error>().map_or(false, |e| {
-				e.message().includes("Using exceptions for control flow", 0)
-			});
-
-			if !is_control_flow_exception {
-				web_sys::console::error_1(&error);
-			}
-		}
-
-		#[wasm_bindgen]
-		extern "C" {
-			#[wasm_bindgen(catch, js_namespace = Function, js_name = "prototype.call.call")]
-			fn call_catch(this: &JsValue) -> Result<(), JsValue>;
-		}
-	});
-}
-
-#[cfg(target_arch = "wasm32")]
-/// Parse the query string as returned by `web_sys::window()?.location().search()?` and get a
-/// specific key out of it.
-pub fn parse_url_query_string<'a>(query: &'a str, search_key: &str) -> Option<&'a str> {
-	let query_string = query.strip_prefix('?')?;
-
-	for pair in query_string.split('&') {
-		let mut pair = pair.split('=');
-		let key = pair.next()?;
-		let value = pair.next()?;
-
-		if key == search_key {
-			return Some(value);
-		}
-	}
-
-	None
-}
-
-// This allows treating the framework as a standalone example,
-// thus avoiding listing the example names in `Cargo.toml`.
-#[allow(dead_code)]
-fn main() {}

src/graphics_worker.rs

@@ -0,0 +1,71 @@
+pub enum Instruction{
+	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),
+	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>(
+		scope:&'a std::thread::Scope<'a,'_>,
+		mut graphics:crate::graphics::GraphicsState,
+		mut config:wgpu::SurfaceConfiguration,
+		surface:wgpu::Surface,
+		device:wgpu::Device,
+		queue:wgpu::Queue,
+	)->crate::worker::INWorker<'a,Instruction>{
+	let mut resize=None;
+	crate::worker::INWorker::new(scope,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)=>{
+				resize=Some((size,user_settings));
+			}
+			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
+				if let Some((size,user_settings))=&resize{
+					println!("Resizing to {:?}",size);
+					let t0=std::time::Instant::now();
+					config.width=size.width.max(1);
+					config.height=size.height.max(1);
+					surface.configure(&device,&config);
+					graphics.resize(&device,&config,user_settings);
+					println!("Resize took {:?}",t0.elapsed());
+				}
+				//clear every time w/e
+				resize=None;
+				//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,6 +41,11 @@ 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]
@@ -310,8 +315,8 @@ impl Angle32{
 	pub fn clamp(&self,theta_min:Self,theta_max:Self)->Self{
 		//((max-min as u32)/2 as i32)+min
 		let midpoint=((
-			u32::from_ne_bytes(theta_max.0.to_ne_bytes())
-			.wrapping_sub(u32::from_ne_bytes(theta_min.0.to_ne_bytes()))
+			(theta_max.0 as u32)
+			.wrapping_sub(theta_min.0 as u32)
 			/2
 		) as i32)//(u32::MAX/2) as i32 ALWAYS works
 		.wrapping_add(theta_min.0);

src/load_roblox.rs

@@ -23,14 +23,6 @@ fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types:
 		}
 	}
 }
-fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
-	let mut objects = std::vec::Vec::new();
-	recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
-	//get ids
-	//clear vec
-	//next class
-	objects
-}
 fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
 	Planar64Affine3::new(
 		Planar64Mat3::from_cols(
@@ -60,6 +52,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
 			force_can_collide=false;
 			general.accelerator=Some(crate::model::GameMechanicAccelerator{acceleration:velocity});
 		},
+		"UnorderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Unordered{mode_id:0}),
 		"SetVelocity"=>general.trajectory=Some(crate::model::GameMechanicSetTrajectory::Velocity(velocity)),
 		"MapFinish"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish})},
 		"MapAnticheat"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat})},
@@ -118,6 +111,12 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
 					"WormholeIn"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::Wormhole(crate::model::GameMechanicWormhole{destination_model_id:captures[2].parse::<u32>().unwrap()})),
 					_=>panic!("regex3[1] messed up bad"),
 				}
+			}else if let Some(captures)=lazy_regex::regex!(r"^(OrderedCheckpoint)(\d+)$")
+			.captures(other){
+				match &captures[1]{
+					"OrderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Ordered{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()}),
+					_=>panic!("regex3[1] messed up bad"),
+				}
 			}
 		}
 	}
@@ -218,9 +217,9 @@ type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 #[derive(Clone,Eq,Hash,PartialEq)]
 enum RobloxBasePartDescription{
-	Sphere,
+	Sphere(RobloxPartDescription),
 	Part(RobloxPartDescription),
-	Cylinder,
+	Cylinder(RobloxPartDescription),
 	Wedge(RobloxWedgeDescription),
 	CornerWedge(RobloxCornerWedgeDescription),
 }
@@ -265,14 +264,12 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 						spawn_point=model_transform.transform_point3(Planar64Vec3::ZERO)+Planar64Vec3::Y*5/2;
 						Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:0}))
 					},
-					"UnorderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::UnorderedCheckpoint(crate::model::TempAttrUnorderedCheckpoint{mode_id:0})),
 					other=>{
-						let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|OrderedCheckpoint|WormholeOut)(\d+)$");
+						let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|WormholeOut)(\d+)$");
 						if let Some(captures) = regman.captures(other) {
 							match &captures[1]{
 								"BonusStart"=>Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:captures[2].parse::<u32>().unwrap()})),
 								"Spawn"|"ForceSpawn"=>Some(crate::model::TempIndexedAttributes::Spawn(crate::model::TempAttrSpawn{mode_id:0,stage_id:captures[2].parse::<u32>().unwrap()})),
-								"OrderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::OrderedCheckpoint(crate::model::TempAttrOrderedCheckpoint{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()})),
 								"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
 								_=>None,
 							}
@@ -301,6 +298,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							panic!("Part has no Shape!");
 						}
 					},
+					"TrussPart"=>primitives::Primitives::Cube,
 					"WedgePart"=>primitives::Primitives::Wedge,
 					"CornerWedgePart"=>primitives::Primitives::CornerWedge,
 					_=>{
@@ -395,9 +393,9 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 					f5,//Cube::Front
 				]=part_texture_description;
 				let basepart_texture_description=match shape{
-					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere,
+					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere([f0,f1,f2,f3,f4,f5]),
 					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
-					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder,
+					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder([f0,f1,f2,f3,f4,f5]),
 					//use front face texture first and use top face texture as a fallback
 					primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
 						f0,//Cube::Right->Wedge::Right
@@ -423,9 +421,10 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 					let model_id=indexed_models.len();
 					model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
 					indexed_models.push(match basepart_texture_description{
-						RobloxBasePartDescription::Sphere=>primitives::unit_sphere(),
-						RobloxBasePartDescription::Part(part_texture_description)=>{
-							let mut cube_face_description=primitives::CubeFaceDescription::new();
+						RobloxBasePartDescription::Sphere(part_texture_description)
+						|RobloxBasePartDescription::Cylinder(part_texture_description)
+						|RobloxBasePartDescription::Part(part_texture_description)=>{
+							let mut cube_face_description=primitives::CubeFaceDescription::default();
 							for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
 								cube_face_description.insert(
 								match face_id{
@@ -444,9 +443,8 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							}
 							primitives::generate_partial_unit_cube(cube_face_description)
 						},
-						RobloxBasePartDescription::Cylinder=>primitives::unit_cylinder(),
 						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
-							let mut wedge_face_description=primitives::WedgeFaceDescription::new();
+							let mut wedge_face_description=primitives::WedgeFaceDescription::default();
 							for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
 								wedge_face_description.insert(
 								match face_id{
@@ -465,7 +463,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							primitives::generate_partial_unit_wedge(wedge_face_description)
 						},
 						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
-							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::new();
+							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::default();
 							for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
 								cornerwedge_face_description.insert(
 								match face_id{

src/model.rs

@@ -50,10 +50,10 @@ pub struct IndexedModelInstances{
 }
 //stage description referencing flattened ids is spooky, but the map loading is meant to be deterministic.
 pub struct ModeDescription{
+	//TODO: put "default" style modifiers in mode
+	//pub style:StyleModifiers,
 	pub start:usize,//start=model_id
 	pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
-	pub ordered_checkpoints:Vec<usize>,//ordered_checkpoints[checkpoint_id]=model_id
-	pub unordered_checkpoints:Vec<usize>,//unordered_checkpoints[checkpoint_id]=model_id
 	pub spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
 	pub ordered_checkpoint_from_checkpoint_id:std::collections::HashMap::<u32,usize>,
 }
@@ -61,9 +61,6 @@ impl ModeDescription{
 	pub fn get_spawn_model_id(&self,stage_id:u32)->Option<&usize>{
 		self.spawns.get(*self.spawn_from_stage_id.get(&stage_id)?)
 	}
-	pub fn get_ordered_checkpoint_model_id(&self,checkpoint_id:u32)->Option<&usize>{
-		self.ordered_checkpoints.get(*self.ordered_checkpoint_from_checkpoint_id.get(&checkpoint_id)?)
-	}
 }
 //I don't want this code to exist!
 #[derive(Clone)]
@@ -76,23 +73,12 @@ pub struct TempAttrSpawn{
 	pub stage_id:u32,
 }
 #[derive(Clone)]
-pub struct TempAttrOrderedCheckpoint{
-	pub mode_id:u32,
-	pub checkpoint_id:u32,
-}
-#[derive(Clone)]
-pub struct TempAttrUnorderedCheckpoint{
-	pub mode_id:u32,
-}
-#[derive(Clone)]
 pub struct TempAttrWormhole{
 	pub wormhole_id:u32,
 }
 pub enum TempIndexedAttributes{
 	Start(TempAttrStart),
 	Spawn(TempAttrSpawn),
-	OrderedCheckpoint(TempAttrOrderedCheckpoint),
-	UnorderedCheckpoint(TempAttrUnorderedCheckpoint),
 	Wormhole(TempAttrWormhole),
 }
 
@@ -126,6 +112,16 @@ pub enum GameMechanicBooster{
 	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
 }
 #[derive(Clone)]
+pub enum GameMechanicCheckpoint{
+	Ordered{
+		mode_id:u32,
+		checkpoint_id:u32,
+	},
+	Unordered{
+		mode_id:u32,
+	},
+}
+#[derive(Clone)]
 pub enum TrajectoryChoice{
 	HighArcLongDuration,//underhand lob at target: less horizontal speed and more air time
 	LowArcShortDuration,//overhand throw at target: more horizontal speed and less air time
@@ -171,6 +167,13 @@ pub enum StageElementBehaviour{
  	Trigger,
  	Teleport,
  	Platform,
+ 	//Acts like a trigger if you haven't hit all the checkpoints.
+ 	Checkpoint{
+ 		//if this is 2 you must have hit OrderedCheckpoint(0) OrderedCheckpoint(1) OrderedCheckpoint(2) to pass
+ 		ordered_checkpoint_id:Option<u32>,
+ 		//if this is 2 you must have hit at least 2 UnorderedCheckpoints to pass
+ 		unordered_checkpoint_count:u32,
+ 	},
  	JumpLimit(u32),
  	//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
 }
@@ -199,15 +202,17 @@ pub enum TeleportBehaviour{
 pub struct GameMechanicAttributes{
 	pub zone:Option<GameMechanicZone>,
 	pub booster:Option<GameMechanicBooster>,
+	pub checkpoint:Option<GameMechanicCheckpoint>,
 	pub trajectory:Option<GameMechanicSetTrajectory>,
 	pub teleport_behaviour:Option<TeleportBehaviour>,
 	pub accelerator:Option<GameMechanicAccelerator>,
 }
 impl GameMechanicAttributes{
 	pub fn any(&self)->bool{
-		self.booster.is_some()
+		self.zone.is_some()
+		||self.booster.is_some()
+		||self.checkpoint.is_some()
 		||self.trajectory.is_some()
-		||self.zone.is_some()
 		||self.teleport_behaviour.is_some()
 		||self.accelerator.is_some()
 	}

src/model_graphics.rs

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

src/physics.rs

@@ -18,7 +18,9 @@ pub enum PhysicsInstruction {
 	Input(PhysicsInputInstruction),
 }
 #[derive(Debug)]
-pub enum PhysicsInputInstruction{
+pub enum PhysicsInputInstruction {
+	ReplaceMouse(MouseState,MouseState),
+	SetNextMouse(MouseState),
 	SetMoveRight(bool),
 	SetMoveUp(bool),
 	SetMoveBack(bool),
@@ -27,52 +29,14 @@ pub enum PhysicsInputInstruction{
 	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
-	ReplaceMouse(MouseState,MouseState),
-	SetNextMouse(MouseState),
 	Reset,
 	Idle,
-}
-#[derive(Debug)]
-#[repr(u32)]
-pub enum InputInstruction {
-	MoveRight(bool)=0,
-	MoveUp(bool)=1,
-	MoveBack(bool)=2,
-	MoveLeft(bool)=3,
-	MoveDown(bool)=4,
-	MoveForward(bool)=5,
-	Jump(bool)=6,
-	Zoom(bool)=7,
-	MoveMouse(glam::IVec2)=64,
-	Reset=100,
-	Idle=127,
 		//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.
 }
-impl InputInstruction{
-	pub fn id(&self)->u32{
-		let parity=match self{
-			crate::physics::InputInstruction::MoveRight(s)
-			|crate::physics::InputInstruction::MoveUp(s)
-			|crate::physics::InputInstruction::MoveBack(s)
-			|crate::physics::InputInstruction::MoveLeft(s)
-			|crate::physics::InputInstruction::MoveDown(s)
-			|crate::physics::InputInstruction::MoveForward(s)
-			|crate::physics::InputInstruction::Jump(s)
-			|crate::physics::InputInstruction::Zoom(s)=>(*s as u32)<<31,
-			crate::physics::InputInstruction::MoveMouse(_)
-			|crate::physics::InputInstruction::Reset
-			|crate::physics::InputInstruction::Idle=>0u32,
-		};
-		self.discriminant()|parity
-	}
-	pub fn discriminant(&self)->u32{
-		//from documentation for std::mem::discriminant(&self)
-		unsafe{*<*const _>::from(self).cast::<u32>()}
-	}
-}
-#[derive(Clone,Hash)]
+
+#[derive(Clone,Hash,Default)]
 pub struct Body {
 	position: Planar64Vec3,//I64 where 2^32 = 1 u
 	velocity: Planar64Vec3,//I64 where 2^32 = 1 u/s
@@ -191,7 +155,7 @@ impl Default for Modes{
 }
 
 struct PhysicsModels{
-	models:Vec<ModelPhysics>,
+	models:Vec<PhysicsModel>,
 	model_id_from_wormhole_id:std::collections::HashMap::<u32,usize>,
 }
 impl PhysicsModels{
@@ -199,13 +163,13 @@ impl PhysicsModels{
 		self.models.clear();
 		self.model_id_from_wormhole_id.clear();
 	}
-	fn get(&self,i:usize)->Option<&ModelPhysics>{
+	fn get(&self,i:usize)->Option<&PhysicsModel>{
 		self.models.get(i)
 	}
-	fn get_wormhole_model(&self,wormhole_id:u32)->Option<&ModelPhysics>{
+	fn get_wormhole_model(&self,wormhole_id:u32)->Option<&PhysicsModel>{
 		self.models.get(*self.model_id_from_wormhole_id.get(&wormhole_id)?)
 	}
-	fn push(&mut self,model:ModelPhysics)->usize{
+	fn push(&mut self,model:PhysicsModel)->usize{
 		let model_id=self.models.len();
 		self.models.push(model);
 		model_id
@@ -221,8 +185,7 @@ impl Default for PhysicsModels{
 }
 
 #[derive(Clone)]
-pub struct PhysicsCamera {
-	offset: Planar64Vec3,
+pub struct PhysicsCamera{
 	//punch: Planar64Vec3,
 	//punch_velocity: Planar64Vec3,
 	sensitivity:Ratio64Vec2,//dots to Angle32 ratios
@@ -240,16 +203,6 @@ pub struct PhysicsCamera {
 }
 
 impl PhysicsCamera {
-	pub fn from_offset(offset:Planar64Vec3) -> Self {
-		Self{
-			offset,
-			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 fn move_mouse(&mut self,mouse_pos:glam::IVec2){
 		let mut unclamped_mouse_pos=self.clamped_mouse_pos+mouse_pos-self.mouse.pos;
 		unclamped_mouse_pos.y=unclamped_mouse_pos.y.clamp(
@@ -280,14 +233,31 @@ impl PhysicsCamera {
 	}
 }
 
+impl std::default::Default for PhysicsCamera{
+	fn default()->Self{
+		Self{
+			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>,
+	stage_id:u32,
+	jump_counts:std::collections::HashMap<usize,u32>,//model_id -> jump count
+	next_ordered_checkpoint_id:u32,//which OrderedCheckpoint model_id you must pass next (if 0 you haven't passed OrderedCheckpoint0)
+	unordered_checkpoints:std::collections::HashSet<usize>,//hashset of UnorderedCheckpoint model ids
 }
 impl std::default::Default for GameMechanicsState{
-	fn default() -> Self {
+	fn default()->Self{
 		Self{
 			stage_id:0,
+			next_ordered_checkpoint_id:0,
+			unordered_checkpoints:std::collections::HashSet::new(),
+			jump_counts:std::collections::HashMap::new(),
 		}
 	}
 }
@@ -311,10 +281,23 @@ enum JumpImpulse{
 //Energy means it adds energy
 //Linear means it linearly adds on
 
+enum EnableStrafe{
+	Always,
+	MaskAny(u32),//hsw, shsw
+	MaskAll(u32),
+	//Function(Box<dyn Fn(u32)->bool>),
+}
+
+struct StrafeSettings{
+	enable:EnableStrafe,
+	air_accel_limit:Option<Planar64>,
+	tick_rate:Ratio64,
+}
+
 struct StyleModifiers{
-	controls_mask:u32,//controls which are unable to be activated
-	controls_held:u32,//controls which must be active to be able to strafe
-	strafe_tick_rate:Ratio64,
+	controls_used:u32,//controls which are allowed to pass into gameplay
+	controls_mask:u32,//controls which are masked from control state (e.g. jump in scroll style)
+	strafe:Option<StrafeSettings>,
 	jump_impulse:JumpImpulse,
 	jump_calculation:JumpCalculation,
 	static_friction:Planar64,
@@ -327,12 +310,13 @@ struct StyleModifiers{
 	swim_speed:Planar64,
 	mass:Planar64,
 	mv:Planar64,
-	air_accel_limit:Option<Planar64>,
+	rocket_force:Option<Planar64>,
 	gravity:Planar64Vec3,
 	hitbox_halfsize:Planar64Vec3,
+	camera_offset:Planar64Vec3,
 }
 impl std::default::Default for StyleModifiers{
-	fn default() -> Self {
+	fn default()->Self{
 		Self::roblox_bhop()
 	}
 }
@@ -352,9 +336,13 @@ impl StyleModifiers{
 
 	fn new()->Self{
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:None,
+				tick_rate:Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
 			jump_calculation:JumpCalculation::Energy,
 			gravity:Planar64Vec3::int(0,-80,0),
@@ -362,7 +350,7 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(2),
-			air_accel_limit:None,
+			rocket_force:None,
 			walk_speed:Planar64::int(16),
 			walk_accel:Planar64::int(80),
 			ladder_speed:Planar64::int(16),
@@ -370,14 +358,19 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 
 	fn roblox_bhop()->Self{
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:None,
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-100,0),
@@ -385,7 +378,7 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
-			air_accel_limit:None,
+			rocket_force:None,
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
 			ladder_speed:Planar64::int(18),
@@ -393,13 +386,18 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 	fn roblox_surf()->Self{
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:None,
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-50,0),
@@ -407,7 +405,7 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
-			air_accel_limit:None,
+			rocket_force:None,
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
 			ladder_speed:Planar64::int(18),
@@ -415,15 +413,19 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 
 	fn source_bhop()->Self{
-		//camera_offset=vec3(0,64/16-73/16/2,0),
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:Some(Planar64::raw(150<<28)*66),
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
 			jump_calculation:JumpCalculation::Linear,
 			gravity:Planar64Vec3::raw(0,-800<<28,0),
@@ -431,7 +433,7 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//?
 			mass:Planar64::int(1),
 			mv:Planar64::raw(30<<28),
-			air_accel_limit:Some(Planar64::raw(150<<28)*66),
+			rocket_force:None,
 			walk_speed:Planar64::int(18),//?
 			walk_accel:Planar64::int(90),//?
 			ladder_speed:Planar64::int(18),//?
@@ -439,14 +441,18 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),//?
 			swim_speed:Planar64::int(12),//?
 			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
+			camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
 		}
 	}
 	fn source_surf()->Self{
-		//camera_offset=vec3(0,64/16-73/16/2,0),
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:Some(Planar64::raw(150<<28)*66),
+				tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
 			jump_calculation:JumpCalculation::Linear,
 			gravity:Planar64Vec3::raw(0,-800<<28,0),
@@ -454,7 +460,7 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//?
 			mass:Planar64::int(1),
 			mv:Planar64::raw(30<<28),
-			air_accel_limit:Some(Planar64::raw(150<<28)*66),
+			rocket_force:None,
 			walk_speed:Planar64::int(18),//?
 			walk_accel:Planar64::int(90),//?
 			ladder_speed:Planar64::int(18),//?
@@ -462,6 +468,30 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),//?
 			swim_speed:Planar64::int(12),//?
 			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
+			camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
+		}
+	}
+	fn roblox_rocket()->Self{
+		Self{
+			controls_used:!0,
+			controls_mask:!0,
+			strafe:None,
+			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
+			jump_calculation:JumpCalculation::Capped,
+			gravity:Planar64Vec3::int(0,-100,0),
+			static_friction:Planar64::int(2),
+			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
+			mass:Planar64::int(1),
+			mv:Planar64::int(27)/10,
+			rocket_force:Some(Planar64::int(200)),
+			walk_speed:Planar64::int(18),
+			walk_accel:Planar64::int(90),
+			ladder_speed:Planar64::int(18),
+			ladder_accel:Planar64::int(180),
+			ladder_dot:(Planar64::int(1)/2).sqrt(),
+			swim_speed:Planar64::int(12),
+			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 
@@ -469,13 +499,19 @@ impl StyleModifiers{
 		controls&self.controls_mask&control==control
 	}
 
+	fn allow_strafe(&self,controls:u32)->bool{
+		//disable strafing according to strafe settings
+		match &self.strafe{
+			Some(StrafeSettings{enable:EnableStrafe::Always,air_accel_limit:_,tick_rate:_})=>true,
+			&Some(StrafeSettings{enable:EnableStrafe::MaskAny(mask),air_accel_limit:_,tick_rate:_})=>mask&controls!=0,
+			&Some(StrafeSettings{enable:EnableStrafe::MaskAll(mask),air_accel_limit:_,tick_rate:_})=>mask&controls==mask,
+			None=>false,
+		}
+	}
+
 	fn get_control_dir(&self,controls:u32)->Planar64Vec3{
 		//don't get fancy just do it
 		let mut control_dir:Planar64Vec3 = Planar64Vec3::ZERO;
-		//Disallow strafing if held controls are not held
-		if controls&self.controls_held!=self.controls_held{
-			return control_dir;
-		}
 		//Apply mask after held check so you can require non-allowed keys to be held for some reason
 		let controls=controls&self.controls_mask;
 		if controls & Self::CONTROL_MOVEFORWARD == Self::CONTROL_MOVEFORWARD {
@@ -531,10 +567,9 @@ impl StyleModifiers{
 		// return cross(cross(Normal,ControlDir),Normal)/sqrt(1-d*d)
 		control_dir*self.walk_speed
 	}
-	fn get_propulsion_target_velocity(&self,camera:&PhysicsCamera,controls:u32,next_mouse:&MouseState,time:Time)->Planar64Vec3{
+	fn get_propulsion_control_dir(&self,camera:&PhysicsCamera,controls:u32,next_mouse:&MouseState,time:Time)->Planar64Vec3{
 		let camera_mat=camera.simulate_move_rotation(camera.mouse.lerp(&next_mouse,time));
-		let control_dir=camera_mat*self.get_control_dir(controls);
-		control_dir*self.walk_speed
+		camera_mat*self.get_control_dir(controls)
 	}
 }
 
@@ -546,15 +581,15 @@ enum MoveState{
 }
 
 pub struct PhysicsState{
-	pub time:Time,
+	time:Time,
 	body:Body,
 	world:WorldState,//currently there is only one state the world can be in
-	pub game:GameMechanicsState,
+	game:GameMechanicsState,
 	style:StyleModifiers,
 	touching:TouchingState,
 	//camera must exist in state because wormholes modify the camera, also camera punch
 	camera:PhysicsCamera,
-	next_mouse:MouseState,//Where is the mouse headed next
+	pub next_mouse:MouseState,//Where is the mouse headed next
 	controls:u32,
 	move_state:MoveState,
 	//all models
@@ -564,16 +599,17 @@ pub struct PhysicsState{
 	modes:Modes,
 	//the spawn point is where you spawn when you load into the map.
 	//This is not the same as Reset which teleports you to Spawn0
-	pub spawn_point:Planar64Vec3,
+	spawn_point:Planar64Vec3,
 }
-#[derive(Clone)]
+#[derive(Clone,Default)]
 pub struct PhysicsOutputState{
-	camera:PhysicsCamera,
 	body:Body,
+	camera:PhysicsCamera,
+	camera_offset:Planar64Vec3,
 }
 impl PhysicsOutputState{
-	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))
+	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))
 	}
 }
 
@@ -592,7 +628,7 @@ enum PhysicsCollisionAttributes{
 	},
 }
 
-pub struct ModelPhysics {
+pub struct PhysicsModel {
 	//A model is a thing that has a hitbox. can be represented by a list of TreyMesh-es
 	//in this iteration, all it needs is extents.
 	mesh: TreyMesh,
@@ -600,7 +636,7 @@ pub struct ModelPhysics {
 	attributes:PhysicsCollisionAttributes,
 }
 
-impl ModelPhysics {
+impl PhysicsModel {
 	fn from_model_transform_attributes(model:&crate::model::IndexedModel,transform:&crate::integer::Planar64Affine3,attributes:PhysicsCollisionAttributes)->Self{
 		let mut aabb=TreyMesh::default();
 		for indexed_vertex in &model.unique_vertices {
@@ -614,8 +650,8 @@ impl ModelPhysics {
 	}
 	pub fn from_model(model:&crate::model::IndexedModel,instance:&crate::model::ModelInstance) -> Option<Self> {
 		match &instance.attributes{
-			crate::model::CollisionAttributes::Contact{contacting,general}=>Some(ModelPhysics::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Contact{contacting:contacting.clone(),general:general.clone()})),
-			crate::model::CollisionAttributes::Intersect{intersecting,general}=>Some(ModelPhysics::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Intersect{intersecting:intersecting.clone(),general:general.clone()})),
+			crate::model::CollisionAttributes::Contact{contacting,general}=>Some(PhysicsModel::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Contact{contacting:contacting.clone(),general:general.clone()})),
+			crate::model::CollisionAttributes::Intersect{intersecting,general}=>Some(PhysicsModel::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Intersect{intersecting:intersecting.clone(),general:general.clone()})),
 			crate::model::CollisionAttributes::Decoration=>None,
 		}
 	}
@@ -642,10 +678,10 @@ pub struct RelativeCollision {
 }
 
 impl RelativeCollision {
-	fn model<'a>(&self,models:&'a PhysicsModels)->Option<&'a ModelPhysics>{
+	fn model<'a>(&self,models:&'a PhysicsModels)->Option<&'a PhysicsModel>{
 		models.get(self.model)
 	}
-	// pub fn mesh(&self,models:&Vec<ModelPhysics>) -> TreyMesh {
+	// pub fn mesh(&self,models:&Vec<PhysicsModel>) -> TreyMesh {
 	// 	return self.model(models).unwrap().face_mesh(self.face).clone()
 	// }
 	fn normal(&self,models:&PhysicsModels) -> Planar64Vec3 {
@@ -732,19 +768,19 @@ impl std::fmt::Display for Body{
 }
 
 impl Default for PhysicsState{
-	fn default() -> Self {
+	fn default()->Self{
  		Self{
 			spawn_point:Planar64Vec3::int(0,50,0),
-			body: Body::with_pva(Planar64Vec3::int(0,50,0),Planar64Vec3::int(0,0,0),Planar64Vec3::int(0,-100,0)),
-			time: Time::ZERO,
+			body:Body::with_pva(Planar64Vec3::int(0,50,0),Planar64Vec3::int(0,0,0),Planar64Vec3::int(0,-100,0)),
+			time:Time::ZERO,
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
 			models:PhysicsModels::default(),
 			bvh:crate::bvh::BvhNode::default(),
 			move_state: MoveState::Air,
-			camera: PhysicsCamera::from_offset(Planar64Vec3::int(0,2,0)),//4.5-2.5=2
-			next_mouse: MouseState::default(),
-			controls: 0,
+			camera:PhysicsCamera::default(),
+			next_mouse:MouseState::default(),
+			controls:0,
 			world:WorldState{},
 			game:GameMechanicsState::default(),
 			modes:Modes::default(),
@@ -757,118 +793,38 @@ impl PhysicsState {
 		self.models.clear();
 		self.modes.clear();
 		self.touching.clear();
-	}
-
-	pub fn into_worker(mut self)->crate::worker::CompatWorker<TimedInstruction<InputInstruction>,PhysicsOutputState,Box<dyn FnMut(TimedInstruction<InputInstruction>)->PhysicsOutputState>>{
-		let mut mouse_blocking=true;
-		let mut last_mouse_time=self.next_mouse.time;
-		let mut timeline=std::collections::VecDeque::new();
-		crate::worker::CompatWorker::new(self.output(),Box::new(move |ins:TimedInstruction<InputInstruction>|{
-			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.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::Idle=>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.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.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.run(instruction.time);
-					self.process_instruction(TimedInstruction{
-						time:instruction.time,
-						instruction:PhysicsInstruction::Input(instruction.instruction),
-					});
-				}
-			}
-			self.output()
-		}))
+		self.bvh=crate::bvh::BvhNode::default();
 	}
 
 	pub fn output(&self)->PhysicsOutputState{
 		PhysicsOutputState{
 			body:self.body.clone(),
 			camera:self.camera.clone(),
+			camera_offset:self.style.camera_offset.clone(),
 		}
 	}
 
+	pub fn spawn(&mut self,spawn_point:Planar64Vec3){
+		self.game.stage_id=0;
+		self.spawn_point=spawn_point;
+		self.process_instruction(crate::instruction::TimedInstruction{
+			time:self.time,
+			instruction: PhysicsInstruction::Input(PhysicsInputInstruction::Reset),
+		});
+	}
+
 	pub fn generate_models(&mut self,indexed_models:&crate::model::IndexedModelInstances){
 		let mut starts=Vec::new();
 		let mut spawns=Vec::new();
-		let mut ordered_checkpoints=Vec::new();
-		let mut unordered_checkpoints=Vec::new();
 		for model in &indexed_models.models{
 			//make aabb and run vertices to get realistic bounds
 			for model_instance in &model.instances{
-				if let Some(model_physics)=ModelPhysics::from_model(model,model_instance){
+				if let Some(model_physics)=PhysicsModel::from_model(model,model_instance){
 					let model_id=self.models.push(model_physics);
 					for attr in &model_instance.temp_indexing{
 						match attr{
 							crate::model::TempIndexedAttributes::Start(s)=>starts.push((model_id,s.clone())),
 							crate::model::TempIndexedAttributes::Spawn(s)=>spawns.push((model_id,s.clone())),
-							crate::model::TempIndexedAttributes::OrderedCheckpoint(s)=>ordered_checkpoints.push((model_id,s.clone())),
-							crate::model::TempIndexedAttributes::UnorderedCheckpoint(s)=>unordered_checkpoints.push((model_id,s.clone())),
 							crate::model::TempIndexedAttributes::Wormhole(s)=>{self.models.model_id_from_wormhole_id.insert(s.wormhole_id,model_id);},
 						}
 					}
@@ -880,9 +836,9 @@ impl PhysicsState {
 		//this code builds ModeDescriptions from the unsorted lists at the top of the function
 		starts.sort_by_key(|tup|tup.1.mode_id);
 		let mut mode_id_from_map_mode_id=std::collections::HashMap::new();
-		let mut modedatas:Vec<(usize,Vec<(u32,usize)>,Vec<(u32,usize)>,Vec<usize>,u32)>=starts.into_iter().enumerate().map(|(i,(model_id,s))|{
+		let mut modedatas:Vec<(usize,Vec<(u32,usize)>,u32)>=starts.into_iter().enumerate().map(|(i,(model_id,s))|{
 			mode_id_from_map_mode_id.insert(s.mode_id,i);
-			(model_id,Vec::new(),Vec::new(),Vec::new(),s.mode_id)
+			(model_id,Vec::new(),s.mode_id)
 		}).collect();
 		for (model_id,s) in spawns{
 			if let Some(mode_id)=mode_id_from_map_mode_id.get(&s.mode_id){
@@ -891,30 +847,13 @@ impl PhysicsState {
 				}
 			}
 		}
-		for (model_id,s) in ordered_checkpoints{
-			if let Some(mode_id)=mode_id_from_map_mode_id.get(&s.mode_id){
-				if let Some(modedata)=modedatas.get_mut(*mode_id){
-					modedata.2.push((s.checkpoint_id,model_id));
-				}
-			}
-		}
-		for (model_id,s) in unordered_checkpoints{
-			if let Some(mode_id)=mode_id_from_map_mode_id.get(&s.mode_id){
-				if let Some(modedata)=modedatas.get_mut(*mode_id){
-					modedata.3.push(model_id);
-				}
-			}
-		}
 		for mut tup in modedatas.into_iter(){
 			tup.1.sort_by_key(|tup|tup.0);
-			tup.2.sort_by_key(|tup|tup.0);
 			let mut eshmep1=std::collections::HashMap::new();
 			let mut eshmep2=std::collections::HashMap::new();
-			self.modes.insert(tup.4,crate::model::ModeDescription{
+			self.modes.insert(tup.2,crate::model::ModeDescription{
 				start:tup.0,
 				spawns:tup.1.into_iter().enumerate().map(|(i,tup)|{eshmep1.insert(tup.0,i);tup.1}).collect(),
-				ordered_checkpoints:tup.2.into_iter().enumerate().map(|(i,tup)|{eshmep2.insert(tup.0,i);tup.1}).collect(),
-				unordered_checkpoints:tup.3,
 				spawn_from_stage_id:eshmep1,
 				ordered_checkpoint_from_checkpoint_id:eshmep2,
 			});
@@ -955,12 +894,14 @@ impl PhysicsState {
 		}
 	}
 
-	fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-		return Some(TimedInstruction{
-			time:Time::from_nanos(self.style.strafe_tick_rate.rhs_div_int(self.style.strafe_tick_rate.mul_int(self.time.nanos())+1)),
-			//only poll the physics if there is a before and after mouse event
-			instruction:PhysicsInstruction::StrafeTick
-		});
+	fn next_strafe_instruction(&self)->Option<TimedInstruction<PhysicsInstruction>>{
+		self.style.strafe.as_ref().map(|strafe|{
+			TimedInstruction{
+				time:Time::from_nanos(strafe.tick_rate.rhs_div_int(strafe.tick_rate.mul_int(self.time.nanos())+1)),
+				//only poll the physics if there is a before and after mouse event
+				instruction:PhysicsInstruction::StrafeTick
+			}
+		})
 	}
 
 	//state mutated on collision:
@@ -994,16 +935,20 @@ impl PhysicsState {
 	// 	});
 	// }
 
-	fn refresh_walk_target(&mut self){
+	fn refresh_walk_target(&mut self)->Option<Planar64Vec3>{
 		match &mut self.move_state{
-			MoveState::Air|MoveState::Water=>(),
+			MoveState::Air|MoveState::Water=>None,
 			MoveState::Walk(WalkState{normal,state})=>{
 				let n=normal;
-				(*state,self.body.acceleration)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
+				let a;
+				(*state,a)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_walk_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
+				Some(a)
 			},
 			MoveState::Ladder(WalkState{normal,state})=>{
 				let n=normal;
-				(*state,self.body.acceleration)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
+				let a;
+				(*state,a)=WalkEnum::with_target_velocity(&self.touching,&self.body,&self.style,&self.models,self.style.get_ladder_target_velocity(&self.camera,self.controls,&self.next_mouse,self.time),&n);
+				Some(a)
 			},
 		}
 	}
@@ -1174,7 +1119,7 @@ impl PhysicsState {
 			},
 		}
 		//generate instruction
-		if let Some(face) = exit_face{
+		if let Some(_face) = exit_face{
 			return Some(TimedInstruction {
 				time: best_time,
 				instruction: PhysicsInstruction::CollisionEnd(collision_data.clone())
@@ -1339,8 +1284,13 @@ fn teleport(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,poi
 	//TODO: calculate contacts and determine the actual state
 	//touching.recalculate(body);
 }
+fn teleport_to_spawn(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,mode:&crate::model::ModeDescription,models:&PhysicsModels,stage_id:u32)->Option<MoveState>{
+	let model=models.get(*mode.get_spawn_model_id(stage_id)? as usize)?;
+	let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox_halfsize.y()+Planar64::ONE/16);
+	Some(teleport(body,touching,style,point))
+}
 
-fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehaviour>,game:&mut GameMechanicsState,models:&PhysicsModels,modes:&Modes,style:&StyleModifiers,touching:&mut TouchingState,body:&mut Body,model:&ModelPhysics)->Option<MoveState>{
+fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehaviour>,game:&mut GameMechanicsState,models:&PhysicsModels,modes:&Modes,style:&StyleModifiers,touching:&mut TouchingState,body:&mut Body,model:&PhysicsModel)->Option<MoveState>{
 	match teleport_behaviour{
 		Some(crate::model::TeleportBehaviour::StageElement(stage_element))=>{
 			if stage_element.force||game.stage_id<stage_element.stage_id{
@@ -1351,12 +1301,24 @@ fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehav
 				crate::model::StageElementBehaviour::Trigger
 				|crate::model::StageElementBehaviour::Teleport=>{
 					//I guess this is correct behaviour when trying to teleport to a non-existent spawn but it's still weird
-					let model=models.get(*modes.get_mode(stage_element.mode_id)?.get_spawn_model_id(game.stage_id)? as usize)?;
-					let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox_halfsize.y()+Planar64::ONE/16);
-					Some(teleport(body,touching,style,point))
+					teleport_to_spawn(body,touching,style,modes.get_mode(stage_element.mode_id)?,models,game.stage_id)
 				},
 				crate::model::StageElementBehaviour::Platform=>None,
-				crate::model::StageElementBehaviour::JumpLimit(_)=>None,//TODO
+				&crate::model::StageElementBehaviour::JumpLimit(jump_limit)=>{
+					//let count=game.jump_counts.get(&model.id);
+					//TODO
+					None
+				},
+				&crate::model::StageElementBehaviour::Checkpoint{ordered_checkpoint_id,unordered_checkpoint_count}=>{
+					if (ordered_checkpoint_id.is_none()||ordered_checkpoint_id.is_some_and(|id|id<game.next_ordered_checkpoint_id))
+						&&unordered_checkpoint_count<=game.unordered_checkpoints.len() as u32{
+						//pass
+						None
+					}else{
+						//fail
+						teleport_to_spawn(body,touching,style,modes.get_mode(stage_element.mode_id)?,models,game.stage_id)
+					}
+				},
 			}
 		},
 		Some(crate::model::TeleportBehaviour::Wormhole(wormhole))=>{
@@ -1380,12 +1342,12 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 		}
 		//selectively update body
 		match &ins.instruction {
-			//PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (),//dodge time for mouse movement
+			PhysicsInstruction::Input(PhysicsInputInstruction::Idle)=>self.time=ins.time,//idle simply updates time
 			PhysicsInstruction::Input(_)
 			|PhysicsInstruction::ReachWalkTargetVelocity
 			|PhysicsInstruction::CollisionStart(_)
 			|PhysicsInstruction::CollisionEnd(_)
-			|PhysicsInstruction::StrafeTick => self.advance_time(ins.time),
+			|PhysicsInstruction::StrafeTick=>self.advance_time(ins.time),
 		}
 		match ins.instruction {
 			PhysicsInstruction::CollisionStart(c) => {
@@ -1431,7 +1393,7 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 								match booster{
 									&crate::model::GameMechanicBooster::Affine(transform)=>v=transform.transform_point3(v),
 									&crate::model::GameMechanicBooster::Velocity(velocity)=>v+=velocity,
-									&crate::model::GameMechanicBooster::Energy{direction,energy}=>todo!(),
+									&crate::model::GameMechanicBooster::Energy{direction: _,energy: _}=>todo!(),
 								}
 								self.touching.constrain_velocity(&self.models,&mut v);
 							},
@@ -1442,10 +1404,10 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 								match trajectory{
 									crate::model::GameMechanicSetTrajectory::AirTime(_) => todo!(),
 									crate::model::GameMechanicSetTrajectory::Height(_) => todo!(),
-									crate::model::GameMechanicSetTrajectory::TargetPointTime { target_point, time } => todo!(),
-									crate::model::GameMechanicSetTrajectory::TrajectoryTargetPoint { target_point, speed, trajectory_choice } => todo!(),
+									crate::model::GameMechanicSetTrajectory::TargetPointTime { target_point: _, time: _ } => todo!(),
+									crate::model::GameMechanicSetTrajectory::TrajectoryTargetPoint { target_point: _, speed: _, trajectory_choice: _ } => todo!(),
 									&crate::model::GameMechanicSetTrajectory::Velocity(velocity)=>v=velocity,
-									crate::model::GameMechanicSetTrajectory::DotVelocity { direction, dot } => todo!(),
+									crate::model::GameMechanicSetTrajectory::DotVelocity { direction: _, dot: _ } => todo!(),
 								}
 								self.touching.constrain_velocity(&self.models,&mut v);
 							},
@@ -1455,9 +1417,11 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 						if self.style.get_control(StyleModifiers::CONTROL_JUMP,self.controls){
 							self.jump();
 						}
-						self.refresh_walk_target();
+						if let Some(a)=self.refresh_walk_target(){
+							self.body.acceleration=a;
+						}
 					},
-					PhysicsCollisionAttributes::Intersect{intersecting,general}=>{
+					PhysicsCollisionAttributes::Intersect{intersecting: _,general}=>{
 						//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
 						self.touching.insert_intersect(c.model,c);
 						run_teleport_behaviour(&general.teleport_behaviour,&mut self.game,&self.models,&self.modes,&self.style,&mut self.touching,&mut self.body,model);
@@ -1467,9 +1431,12 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 			PhysicsInstruction::CollisionEnd(c) => {
 				let model=c.model(&self.models).unwrap();
 				match &model.attributes{
-					PhysicsCollisionAttributes::Contact{contacting,general}=>{
+					PhysicsCollisionAttributes::Contact{contacting: _,general: _}=>{
 						self.touching.remove_contact(c.model);//remove contact before calling contact_constrain_acceleration
 						let mut a=self.style.gravity;
+						if let Some(rocket_force)=self.style.rocket_force{
+							a+=self.style.get_propulsion_control_dir(&self.camera,self.controls,&self.next_mouse,self.time)*rocket_force;
+						}
 						self.touching.constrain_acceleration(&self.models,&mut a);
 						self.body.acceleration=a;
 						//check ground
@@ -1479,10 +1446,12 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 								//TODO: make this more advanced checking contacts
 								self.move_state=MoveState::Air;
 							},
-							_=>self.refresh_walk_target(),
+							_=>if let Some(a)=self.refresh_walk_target(){
+								self.body.acceleration=a;
+							},
 						}
 					},
-					PhysicsCollisionAttributes::Intersect{intersecting,general}=>{
+					PhysicsCollisionAttributes::Intersect{intersecting: _,general: _}=>{
 						self.touching.remove_intersect(c.model);
 					},
 				}
@@ -1556,7 +1525,14 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 					PhysicsInputInstruction::Idle => {refresh_walk_target=false;},//literally idle!
 				}
 				if refresh_walk_target{
-					self.refresh_walk_target();
+					if let Some(a)=self.refresh_walk_target(){
+						self.body.acceleration=a;
+					}else if let Some(rocket_force)=self.style.rocket_force{
+						let mut a=self.style.gravity;
+						a+=self.style.get_propulsion_control_dir(&self.camera,self.controls,&self.next_mouse,self.time)*rocket_force;
+						self.touching.constrain_acceleration(&self.models,&mut a);
+						self.body.acceleration=a;
+					}
 				}
 			},
 		}

src/physics_worker.rs

@@ -0,0 +1,134 @@
+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<'a>(scope:&'a std::thread::Scope<'a,'_>,mut physics:crate::physics::PhysicsState,graphics_worker:crate::worker::INWorker<'a,crate::graphics_worker::Instruction>)->crate::worker::QNWorker<'a,TimedInstruction<Instruction>>{
+		let mut mouse_blocking=true;
+		let mut last_mouse_time=physics.next_mouse.time;
+		let mut timeline=std::collections::VecDeque::new();
+		crate::worker::QNWorker::new(scope,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=>{
+					let _=graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos));
+				},
+				Instruction::Resize(size,user_settings)=>{
+					//block!
+					graphics_worker.blocking_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

@@ -126,17 +126,21 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	Planar64Vec3::int( 0,-1, 0),//CornerWedge::Bottom
 	Planar64Vec3::int( 0, 0,-1),//CornerWedge::Front
 ];
-//HashMap fits this use case perfectly but feels like using a sledgehammer to drive a nail
 pub fn unit_sphere()->crate::model::IndexedModel{
-	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),Color4::ONE).remove(0);
-	for pos in indexed_model.unique_pos.iter_mut(){
-		*pos=*pos/2;
-	}
-	indexed_model
+	unit_cube()
+}
+#[derive(Default)]
+pub struct CubeFaceDescription([Option<FaceDescription>;6]);
+impl CubeFaceDescription{
+	pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,6>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	}
 }
-pub type CubeFaceDescription=std::collections::HashMap::<CubeFace,FaceDescription>;
 pub fn unit_cube()->crate::model::IndexedModel{
-	let mut t=CubeFaceDescription::new();
+	let mut t=CubeFaceDescription::default();
 	t.insert(CubeFace::Right,FaceDescription::default());
 	t.insert(CubeFace::Top,FaceDescription::default());
 	t.insert(CubeFace::Back,FaceDescription::default());
@@ -145,17 +149,21 @@ pub fn unit_cube()->crate::model::IndexedModel{
 	t.insert(CubeFace::Front,FaceDescription::default());
 	generate_partial_unit_cube(t)
 }
-const TEAPOT_TRANSFORM:crate::integer::Planar64Mat3=crate::integer::Planar64Mat3::int_from_cols_array([0,1,0, -1,0,0, 0,0,1]);
 pub fn unit_cylinder()->crate::model::IndexedModel{
-	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),Color4::ONE).remove(0);
-	for pos in indexed_model.unique_pos.iter_mut(){
-		*pos=TEAPOT_TRANSFORM*(*pos)/10;
-	}
-	indexed_model
+	unit_cube()
+}
+#[derive(Default)]
+pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
+impl WedgeFaceDescription{
+	pub fn insert(&mut self,index:WedgeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	}
 }
-pub type WedgeFaceDescription=std::collections::HashMap::<WedgeFace,FaceDescription>;
 pub fn unit_wedge()->crate::model::IndexedModel{
-	let mut t=WedgeFaceDescription::new();
+	let mut t=WedgeFaceDescription::default();
 	t.insert(WedgeFace::Right,FaceDescription::default());
 	t.insert(WedgeFace::TopFront,FaceDescription::default());
 	t.insert(WedgeFace::Back,FaceDescription::default());
@@ -163,9 +171,18 @@ pub fn unit_wedge()->crate::model::IndexedModel{
 	t.insert(WedgeFace::Bottom,FaceDescription::default());
 	generate_partial_unit_wedge(t)
 }
-pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,FaceDescription>;
+#[derive(Default)]
+pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
+impl CornerWedgeFaceDescription{
+	pub fn insert(&mut self,index:CornerWedgeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	}
+}
 pub fn unit_cornerwedge()->crate::model::IndexedModel{
-	let mut t=CornerWedgeFaceDescription::new();
+	let mut t=CornerWedgeFaceDescription::default();
 	t.insert(CornerWedgeFace::Right,FaceDescription::default());
 	t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
@@ -189,18 +206,6 @@ impl std::default::Default for FaceDescription{
 		}
 	}
 }
-impl FaceDescription{
-	pub fn new(texture:u32,transform:glam::Affine2,color:Color4)->Self{
-		Self{texture:Some(texture),transform,color}
-	}
-	pub fn from_texture(texture:u32)->Self{
-		Self{
-			texture:Some(texture),
-			transform:glam::Affine2::IDENTITY,
-			color:Color4::ONE,
-		}
-	}
-}
 //TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
 //implementation: put all roblox primitives into one model.groups <- this won't work but I forget why
 pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate::model::IndexedModel{
@@ -212,7 +217,7 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face,face_description) in face_descriptions.into_iter(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -233,14 +238,6 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
 			generated_color.push(face_description.color);
 			color_index
 		} as u32;
-		let face_id=match face{
-			CubeFace::Right => 0,
-			CubeFace::Top => 1,
-			CubeFace::Back => 2,
-			CubeFace::Left => 3,
-			CubeFace::Bottom => 4,
-			CubeFace::Front => 5,
-		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;
 		generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
@@ -327,7 +324,7 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face,face_description) in face_descriptions.into_iter(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -348,13 +345,6 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
 			generated_color.push(face_description.color);
 			color_index
 		} as u32;
-		let face_id=match face{
-			WedgeFace::Right => 0,
-			WedgeFace::TopFront => 1,
-			WedgeFace::Back => 2,
-			WedgeFace::Left => 3,
-			WedgeFace::Bottom => 4,
-		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;
 		generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
@@ -439,7 +429,7 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face,face_description) in face_descriptions.into_iter(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -460,13 +450,6 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 			generated_color.push(face_description.color);
 			color_index
 		} as u32;
-		let face_id=match face{
-			CornerWedgeFace::Right => 0,
-			CornerWedgeFace::TopBack => 1,
-			CornerWedgeFace::TopLeft => 2,
-			CornerWedgeFace::Bottom => 3,
-			CornerWedgeFace::Front => 4,
-		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;
 		generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);

src/settings.rs

@@ -1,11 +1,14 @@
 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},
@@ -16,9 +19,11 @@ 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},
@@ -30,7 +35,7 @@ impl Default for Sensitivity{
 	}
 }
 
-#[derive(Default)]
+#[derive(Default,Clone)]
 pub struct UserSettings{
 	fov:Fov,
 	sensitivity:Sensitivity,

src/setup.rs

@@ -0,0 +1,315 @@
+use crate::instruction::TimedInstruction;
+use crate::window::WindowInstruction;
+
+fn optional_features()->wgpu::Features{
+	wgpu::Features::TEXTURE_COMPRESSION_ASTC
+	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
+}
+fn required_features()->wgpu::Features{
+	wgpu::Features::TEXTURE_COMPRESSION_BC
+}
+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()
+}
+
+struct SetupContextPartial1{
+	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{
+	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{
+		backends,
+		instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
+			backends,
+			dx12_shader_compiler,
+			..Default::default()
+		}),
+	}
+}
+impl SetupContextPartial1{
+	fn create_surface(self,window:&winit::window::Window)->Result<SetupContextPartial2,wgpu::CreateSurfaceError>{
+		Ok(SetupContextPartial2{
+			backends:self.backends,
+			surface:unsafe{self.instance.create_surface(window)}?,
+			instance:self.instance,
+		})
+	}
+}
+struct SetupContextPartial2{
+	backends:wgpu::Backends,
+	instance:wgpu::Instance,
+	surface:wgpu::Surface,
+}
+impl SetupContextPartial2{
+	fn pick_adapter(self)->SetupContextPartial3{
+		let adapter;
+
+		//TODO: prefer adapter that implements optional features
+		//let optional_features=optional_features();
+		let required_features=required_features();
+
+		//no helper function smh gotta write it myself
+		let adapters=self.instance.enumerate_adapters(self.backends);
+
+		let mut chosen_adapter=None;
+		let mut chosen_adapter_score=0;
+		for adapter in adapters {
+			if !adapter.is_surface_supported(&self.surface) {
+				continue;
+			}
+
+			let score=match adapter.get_info().device_type{
+				wgpu::DeviceType::IntegratedGpu=>3,
+				wgpu::DeviceType::DiscreteGpu=>4,
+				wgpu::DeviceType::VirtualGpu=>2,
+				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
+			};
+
+			let adapter_features=adapter.features();
+			if chosen_adapter_score<score&&adapter_features.contains(required_features) {
+				chosen_adapter_score=score;
+				chosen_adapter=Some(adapter);
+			}
+		}
+
+		if let Some(maybe_chosen_adapter)=chosen_adapter{
+			adapter=maybe_chosen_adapter;
+		}else{
+			panic!("No suitable GPU adapters found on the system!");
+		}
+
+
+		let adapter_info=adapter.get_info();
+		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
+
+		let required_downlevel_capabilities=required_downlevel_capabilities();
+		let downlevel_capabilities=adapter.get_downlevel_capabilities();
+		assert!(
+			downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
+			"Adapter does not support the minimum shader model required to run this example: {:?}",
+			required_downlevel_capabilities.shader_model
+		);
+		assert!(
+			downlevel_capabilities
+				.flags
+				.contains(required_downlevel_capabilities.flags),
+			"Adapter does not support the downlevel capabilities required to run this example: {:?}",
+			required_downlevel_capabilities.flags - downlevel_capabilities.flags
+		);
+		SetupContextPartial3{
+			instance:self.instance,
+			surface:self.surface,
+			adapter,
+		}
+	}
+}
+struct SetupContextPartial3{
+	instance:wgpu::Instance,
+	surface:wgpu::Surface,
+	adapter:wgpu::Adapter,
+}
+impl SetupContextPartial3{
+	fn request_device(self)->SetupContextPartial4{
+		let optional_features=optional_features();
+		let required_features=required_features();
+
+		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
+		let needed_limits=required_limits().using_resolution(self.adapter.limits());
+
+		let trace_dir=std::env::var("WGPU_TRACE");
+		let (device, queue)=pollster::block_on(self.adapter
+			.request_device(
+				&wgpu::DeviceDescriptor {
+					label: None,
+					features: (optional_features & self.adapter.features()) | required_features,
+					limits: needed_limits,
+				},
+				trace_dir.ok().as_ref().map(std::path::Path::new),
+			))
+			.expect("Unable to find a suitable GPU adapter!");
+
+		SetupContextPartial4{
+			instance:self.instance,
+			surface:self.surface,
+			adapter:self.adapter,
+			device,
+			queue,
+		}
+	}
+}
+struct SetupContextPartial4{
+	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{
+		let mut config=self.surface
+			.get_default_config(&self.adapter, size.width, size.height)
+			.expect("Surface isn't supported by the adapter.");
+		let surface_view_format=config.format.add_srgb_suffix();
+		config.view_formats.push(surface_view_format);
+		config.present_mode=wgpu::PresentMode::AutoNoVsync;
+		self.surface.configure(&self.device, &config);
+
+		SetupContext{
+			instance:self.instance,
+			surface:self.surface,
+			device:self.device,
+			queue:self.queue,
+			config,
+		}
+	}
+}
+pub struct SetupContext{
+	pub instance:wgpu::Instance,
+	pub surface:wgpu::Surface,
+	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();
+
+	let window=create_window(title,&event_loop).unwrap();
+
+	println!("Initializing the surface...");
+
+	let partial_1=create_instance();
+
+	let partial_2=partial_1.create_surface(&window).unwrap();
+
+	let partial_3=partial_2.pick_adapter();
+
+	let partial_4=partial_3.request_device();
+
+	SetupContextSetup{
+		window,
+		event_loop,
+		partial_context:partial_4,
+	}
+}
+
+pub struct SetupContextSetup{
+	window:winit::window::Window,
+	event_loop:winit::event_loop::EventLoop<()>,
+	partial_context:SetupContextPartial4,
+}
+
+impl SetupContextSetup{
+	fn into_split(self)->(winit::window::Window,winit::event_loop::EventLoop<()>,SetupContext){
+		let size=self.window.inner_size();
+		//Steal values and drop self
+		(
+			self.window,
+			self.event_loop,
+			self.partial_context.configure_surface(&size),
+		)
+	}
+	pub fn start(self){
+		let (window,event_loop,setup_context)=self.into_split();
+
+		//dedicated thread to ping request redraw back and resize the window doesn't seem logical
+		//but here I am doing it
+		let root_time=std::time::Instant::now();
+		std::thread::scope(|s|{
+			let window=crate::window::WindowContextSetup::new(&setup_context,window);
+			//the thread that spawns the physics thread
+			let window_thread=window.into_worker(s,setup_context);
+
+			//schedule frames at 165fps
+			let event_loop_proxy=event_loop.create_proxy();
+
+			s.spawn(move ||{
+				loop{
+					std::thread::sleep(std::time::Duration::from_nanos(1_000_000_000/165));
+					event_loop_proxy.send_event(()).ok();
+				}
+			});
+
+			println!("Entering event loop...");
+			run_event_loop(event_loop,window_thread,root_time).unwrap();
+		});
+	}
+}
+
+fn run_event_loop(
+	event_loop:winit::event_loop::EventLoop<()>,
+	window_thread:crate::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
+			// };
+			match event{
+				winit::event::Event::UserEvent(())=>{
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::RequestRedraw}).unwrap();
+				}
+				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:_,
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Resize(size)}).unwrap();
+				}
+				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),
+								state: winit::event::ElementState::Pressed,
+								..
+							},
+						..
+					}
+					|winit::event::WindowEvent::CloseRequested=>{
+						elwt.exit();
+					}
+					winit::event::WindowEvent::RedrawRequested=>{
+						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Render}).unwrap();
+					}
+					_=>{
+						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::WindowEvent(event)}).unwrap();
+					}
+				},
+				winit::event::Event::DeviceEvent{
+					event,
+					..
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::DeviceEvent(event)}).unwrap();
+				},
+				_=>{}
+			}
+		})
+}

src/sniffer.rs

@@ -1,134 +0,0 @@
-//file format "sniff"
-
-/* spec
-
-//begin global header
-
-//global metadata (32 bytes)
-b"SNFB"
-u32 format_version
-u64 priming_bytes
-	//how many bytes of the file must be read to guarantee all of the expected
-	//format-specific metadata is available to facilitate streaming the remaining contents
-	//used by the database to guarantee that it serves at least the bare minimum
-u128 resource_uuid
-	//identifies the file from anywhere for any other file
-
-//global block layout (variable size)
-u64 num_blocks
-for block_id in 0..num_blocks{
-	u64 first_byte
-}
-
-//end global header
-
-//begin blocks
-
-//each block is compressed with zstd or gz or something
-
-*/
-
-/* block types
-BLOCK_MAP_HEADER:
-StyleInfoOverrides style_info_overrides
-//bvh goes here
-u64 num_nodes
-//node 0 parent node is implied to be None
-for node_id in 1..num_nodes{
-	u64 parent_node
-}
-//block 0 is the current block, not part of the map data
-u64 num_spacial_blocks
-for block_id in 1..num_spacial_blocks{
-	u64 node_id
-	u64 block_id
-	Aabb block_extents
-}
-//ideally spacial blocks are sorted from distance to start zone
-//texture blocks are inserted before the first spacial block they are used in
-
-BLOCK_MAP_RESOURCE:
-//an individual one of the following:
-	- model (IndexedModel)
-	- shader (compiled SPIR-V)
-	- image (JpegXL)
-	- sound (Opus)
-	- video (AV1)
-	- animation (Trey thing)
-
-BLOCK_MAP_OBJECT:
-//an individual one of the following:
-	- model instance
-	- located resource
-//for a list of resources, parse the object.
-
-BLOCK_BOT_HEADER:
-u128 map_resource_uuid //which map is this bot running
-u128 time_resource_uuid //resource database time
-//don't include style info in bot header because it's in the physics state
-//blocks are laid out in chronological order, but indices may jump around.
-u64 num_segments
-for _ in 0..num_segments{
-	i64 time //physics_state timestamp
-	u64 block_id
-}
-
-BLOCK_BOT_SEGMENT:
-//format version indicates what version of these structures to use
-PhysicsState physics_state 
-//to read, greedily decode instructions until eof
-loop{
-	//delta encode as much as possible (time,mousepos)
-	//strafe ticks are implied
-	//physics can be implied in an input-only bot file
-	TimedInstruction<PhysicsInstruction> instruction
-}
-
-BLOCK_DEMO_HEADER:
-//timeline of loading maps, player equipment, bots
-*/
-struct InputInstructionCodecState{
-	mouse_pos:glam::IVec2,
-	time:crate::integer::Time,
-}
-//8B - 12B
-impl InputInstructionCodecState{
-	pub fn encode(&mut self,ins:&crate::instruction::TimedInstruction<crate::physics::InputInstruction>)->([u8;12],usize){
-		let dt=ins.time-self.time;
-		self.time=ins.time;
-		let mut data=[0u8;12];
-		[data[0],data[1],data[2],data[3]]=(dt.nanos() as u32).to_le_bytes();//4B
-		//instruction id packed with game control parity bit.  This could be 1 byte but it ruins the alignment
-		[data[4],data[5],data[6],data[7]]=ins.instruction.id().to_le_bytes();//4B
-		match &ins.instruction{
-			&crate::physics::InputInstruction::MoveMouse(m)=>{//4B
-				let dm=m-self.mouse_pos;
-				[data[8],data[9]]=(dm.x as i16).to_le_bytes();
-				[data[10],data[11]]=(dm.y as i16).to_le_bytes();
-				self.mouse_pos=m;
-				(data,12)
-			},
-			//0B
-			crate::physics::InputInstruction::MoveRight(_)
-			|crate::physics::InputInstruction::MoveUp(_)
-			|crate::physics::InputInstruction::MoveBack(_)
-			|crate::physics::InputInstruction::MoveLeft(_)
-			|crate::physics::InputInstruction::MoveDown(_)
-			|crate::physics::InputInstruction::MoveForward(_)
-			|crate::physics::InputInstruction::Jump(_)
-			|crate::physics::InputInstruction::Zoom(_)
-			|crate::physics::InputInstruction::Reset
-			|crate::physics::InputInstruction::Idle=>(data,8),
-		}
-	}
-}
-
-//everything must be 4 byte aligned, it's all going to be compressed so don't think too had about saving less than 4 bytes
-//TODO: Omit (mouse only?) instructions that don't surround an actual physics instruction
-fn write_input_instruction<W:std::io::Write>(state:&mut InputInstructionCodecState,w:&mut W,ins:&crate::instruction::TimedInstruction<crate::physics::InputInstruction>)->Result<usize,std::io::Error>{
-	//TODO: insert idle instruction if gap is over u32 nanoseconds
-	//TODO: don't write idle instructions
-	//OR: end the data block! the full state at the start of the next block will contain an absolute timestamp
-	let (data,size)=state.encode(ins);
-	w.write(&data[0..size])//8B-12B
-}

src/window.rs

@@ -0,0 +1,243 @@
+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,
+}
+
+//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::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) {
+		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();
+				}
+			},
+			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,..},
+				..
+			}=>{
+				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)=>{
+						if s{
+							self.manual_mouse_lock=false;
+							match self.window.set_cursor_position(self.get_middle_of_screen()){
+								Ok(())=>(),
+								Err(e)=>println!("Could not set cursor position: {:?}",e),
+							}
+							match self.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){
+								Ok(())=>(),
+								Err(_)=>{
+									match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+										Ok(())=>(),
+										Err(e)=>{
+											self.manual_mouse_lock=true;
+											println!("Could not confine cursor: {:?}",e)
+										},
+									}
+								}
+							}
+						}
+						self.window.set_cursor_visible(s);
+					},
+					winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11)=>{
+						if s{
+							if self.window.fullscreen().is_some(){
+								self.window.set_fullscreen(None);
+							}else{
+								self.window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
+							}
+						}
+					},
+					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape)=>{
+						if s{
+							self.manual_mouse_lock=false;
+							match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+								Ok(())=>(),
+								Err(e)=>println!("Could not release cursor: {:?}",e),
+							}
+							self.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,
+						}{
+							self.physics_thread.send(TimedInstruction{
+								time,
+								instruction:crate::physics_worker::Instruction::Input(input_instruction),
+							}).unwrap();
+						}
+					},
+				}
+			},
+			_=>(),
+		}
+	}
+
+	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
+			} => {
+				if self.manual_mouse_lock{
+					match self.window.set_cursor_position(self.get_middle_of_screen()){
+						Ok(())=>(),
+						Err(e)=>println!("Could not set cursor position: {:?}",e),
+					}
+				}
+				//do not step the physics because the mouse polling rate is higher than the physics can run.
+				//essentially the previous input will be overwritten until a true step runs
+				//which is fine because they run all the time.
+				let delta=glam::ivec2(delta.0 as i32,delta.1 as i32);
+				self.mouse.pos+=delta;
+				self.physics_thread.send(TimedInstruction{
+					time,
+					instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
+				}).unwrap();
+			},
+			winit::event::DeviceEvent::MouseWheel {
+			    delta,
+			} => {
+				println!("mousewheel {:?}",delta);
+				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
+					}).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,
+		}
+	}
+
+	fn into_context<'a>(self,scope:&'a std::thread::Scope<'a,'_>,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(scope,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(scope,self.physics,graphics_thread),
+		}
+	}
+
+	pub fn into_worker<'a>(self,scope:&'a std::thread::Scope<'a,'_>,setup_context:crate::setup::SetupContext)->crate::worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
+		let mut window_context=self.into_context(scope,setup_context);
+		crate::worker::QNWorker::new(scope,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();
+				}
+			}
+		})
+	}
+}

src/worker.rs

@@ -2,16 +2,68 @@ use std::thread;
 use std::sync::{mpsc,Arc};
 use parking_lot::Mutex;
 
+//WorkerPool
+struct Pool(u32);
+enum PoolOrdering{
+	Single,//single thread cannot get out of order
+	Ordered(u32),//order matters and should be buffered/dropped according to ControlFlow
+	Unordered(u32),//order does not matter
+}
+//WorkerInput
+enum Input{
+	//no input, workers have everything needed at creation
+	None,
+	//Immediate input to any available worker, dropped if they are overflowing (all workers are busy)
+	Immediate,
+	//Queued input is ordered, but serial jobs that mutate state (such as running physics) can only be done with a single worker
+	Queued,//"Fifo"
+	//Query a function to get next input when a thread becomes available
+	//worker stops querying when Query function returns None and dies after all threads complete
+	//lifetimes sound crazy on this one
+	Query,
+	//Queue of length one, the input is replaced if it is submitted twice before the current work finishes
+	Mailbox,
+}
+//WorkerOutput
+enum Output{
+	None(Pool),
+	Realtime(PoolOrdering),//outputs are dropped if they are out of order and order is demanded
+	Buffered(PoolOrdering),//outputs are held back internally if they are out of order and order is demanded
+}
+
+//It would be possible to implement all variants
+//with a query input function and callback output function but I'm not sure if that's worth it.
+//Immediate = Condvar
+//Queued = receiver.recv()
+//a callback function would need to use an async runtime!
+
+//realtime output is an arc mutex of the output value that is assigned every time a worker completes a job
+//buffered output produces a receiver object that can be passed to the creation of another worker
+//when ordering is requested, output is ordered by the order each thread is run
+//which is the same as the order that the input data is processed except for Input::None which has no input data
+//WorkerDescription
+struct Description{
+	input:Input,
+	output:Output,
+}
+
 //The goal here is to have a worker thread that parks itself when it runs out of work.
 //The worker thread publishes the result of its work back to the worker object for every item in the work queue.
+//Previous values do not matter as soon as a new value is produced, which is why it's called "Realtime"
 //The physics (target use case) knows when it has not changed the body, so not updating the value is also an option.
 
-pub struct Worker<Task:Send,Value:Clone> {
+/*
+QR = WorkerDescription{
+	input:Queued,
+	output:Realtime(Single),
+}
+*/
+pub struct QRWorker<Task:Send,Value:Clone>{
 	sender: mpsc::Sender<Task>,
 	value:Arc<Mutex<Value>>,
 }
 
-impl<Task:Send+'static,Value:Clone+Send+'static> Worker<Task,Value> {
+impl<Task:Send+'static,Value:Clone+Send+'static> QRWorker<Task,Value>{
 	pub fn new<F:FnMut(Task)->Value+Send+'static>(value:Value,mut f:F) -> Self {
 		let (sender, receiver) = mpsc::channel::<Task>();
 		let ret=Self {
@@ -45,28 +97,79 @@ impl<Task:Send+'static,Value:Clone+Send+'static> Worker<Task,Value> {
 	}
 }
 
-pub struct CompatWorker<Task,Value:Clone,F>{
-	data:std::marker::PhantomData<Task>,
-	f:F,
-	value:Value,
+/*
+QN = WorkerDescription{
+	input:Queued,
+	output:None(Single),
+}
+*/
+//None Output Worker does all its work internally from the perspective of the work submitter
+pub struct QNWorker<'a,Task:Send>{
+	sender: mpsc::Sender<Task>,
+	handle:thread::ScopedJoinHandle<'a,()>,
 }
 
-impl<Task,Value:Clone,F:FnMut(Task)->Value> CompatWorker<Task,Value,F> {
-	pub fn new(value:Value,f:F) -> Self {
-		Self {
-			f,
-			value,
-			data:std::marker::PhantomData,
+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>{
+		let (sender,receiver)=mpsc::channel::<Task>();
+		let handle=scope.spawn(move ||{
+			loop {
+				match receiver.recv() {
+					Ok(task)=>f(task),
+					Err(_)=>{
+						println!("Worker stopping.",);
+						break;
+					}
+				}
+			}
+		});
+		Self{
+			sender,
+			handle,
 		}
 	}
-
-	pub fn send(&mut self,task:Task)->Result<(),()>{
-		self.value=(self.f)(task);
-		Ok(())
+	pub fn send(&self,task:Task)->Result<(),mpsc::SendError<Task>>{
+		self.sender.send(task)
 	}
+}
 
-	pub fn grab_clone(&self)->Value{
-		self.value.clone()
+/*
+IN = WorkerDescription{
+	input:Immediate,
+	output:None(Single),
+}
+*/
+//Inputs are dropped if the worker is busy
+pub struct INWorker<'a,Task:Send>{
+	sender: mpsc::SyncSender<Task>,
+	handle:thread::ScopedJoinHandle<'a,()>,
+}
+
+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 ||{
+			loop {
+				match receiver.recv() {
+					Ok(task)=>f(task),
+					Err(_)=>{
+						println!("Worker stopping.",);
+						break;
+					}
+				}
+			}
+		});
+		Self{
+			sender,
+			handle,
+		}
+	}
+	//blocking!
+	pub fn blocking_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)
 	}
 }
 
@@ -74,7 +177,7 @@ impl<Task,Value:Clone,F:FnMut(Task)->Value> CompatWorker<Task,Value,F> {
 fn test_worker() {
 	println!("hiiiii");
 	// Create the worker thread
-	let worker = Worker::new(crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO),
+	let worker=QRWorker::new(crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO,crate::integer::Planar64Vec3::ZERO),
 		|_|crate::physics::Body::with_pva(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE)
 	);
 

tools/arcane

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

tools/bhop_maps

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

tools/cross-compile.sh

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

tools/make-demo.sh

@@ -0,0 +1,4 @@
+mkdir -p ../target/demo
+mv ../target/x86_64-pc-windows-gnu/release/strafe-client.exe ../target/demo/strafe-client.exe
+rm ../target/demo.7z
+7z a -t7z -mx=9 -mfb=273 -ms -md=31 -myx=9 -mtm=- -mmt -mmtf -md=1536m -mmf=bt3 -mmc=10000 -mpb=0 -mlc=0 ../target/demo.7z ../target/demo

tools/run

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client "$1"

tools/settings.conf

@@ -0,0 +1,4 @@
+[camera]
+sensitivity_x=98384
+fov_y=1.0
+#fov_x_from_y_ratio=1.33333333333333333333333333333333

tools/textures

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

tools/toc

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