md generic

these were supposed to be 3 voxels but were on the order of 3 units

Cargo.toml

@@ -35,22 +35,3 @@ unused_lifetimes = "warn"
 unused_qualifications = "warn"
 # variant_size_differences = "warn"
 unexpected_cfgs = "warn"
-
-[workspace.dependencies]
-glam = "0.31.0"
-
-# engine
-strafesnet_graphics = { path = "engine/graphics", registry = "strafesnet" }
-strafesnet_physics = { version = "0.0.1", path = "engine/physics", registry = "strafesnet" }
-strafesnet_session = { path = "engine/session", registry = "strafesnet" }
-strafesnet_settings = { path = "engine/settings", registry = "strafesnet" }
-
-# lib
-fixed_wide = { version = "0.2.2", path = "lib/fixed_wide", registry = "strafesnet" }
-linear_ops = { version = "0.1.1", path = "lib/linear_ops", registry = "strafesnet" }
-ratio_ops = { version = "0.1.0", path = "lib/ratio_ops", registry = "strafesnet" }
-strafesnet_bsp_loader = { path = "lib/bsp_loader", registry = "strafesnet" }
-strafesnet_common = { version = "0.8.5", path = "lib/common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.1", path = "lib/deferred_loader", registry = "strafesnet" }
-strafesnet_rbx_loader = { path = "lib/rbx_loader", registry = "strafesnet" }
-strafesnet_snf = { version = "0.3.2", path = "lib/snf", registry = "strafesnet" }

engine/graphics/Cargo.toml

@@ -1,15 +1,17 @@
 [package]
 name = "strafesnet_graphics"
-version = "0.0.2"
+version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 bytemuck = { version = "1.13.1", features = ["derive"] }
 ddsfile = "0.5.1"
-glam.workspace = true
+glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common.workspace = true
-wgpu = "28.0.0"
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+strafesnet_session = { path = "../session", registry = "strafesnet" }
+strafesnet_settings = { path = "../settings", registry = "strafesnet" }
+wgpu = "27.0.0"
 
 [lints]
 workspace = true

engine/graphics/src/graphics.rs

@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 use std::collections::{HashSet,HashMap};
 use strafesnet_common::map;
+use strafesnet_settings::settings;
+use strafesnet_session::session;
 use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
 use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
@@ -52,10 +54,6 @@ struct GraphicsPipelines{
 	model:wgpu::RenderPipeline,
 }
 
-pub fn view_inv(pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
-	//f32 good enough for view matrix
-	glam::Mat4::from_mat3_translation(glam::Mat3::from_euler(glam::EulerRot::YXZ,angles.x,angles.y,0f32),pos)
-}
 struct GraphicsCamera{
 	screen_size:glam::UVec2,
 	fov:glam::Vec2,//slope
@@ -77,10 +75,15 @@ impl GraphicsCamera{
 	pub fn proj(&self)->glam::Mat4{
 		perspective_rh(self.fov.x,self.fov.y,0.4,4000.0)
 	}
+	pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
+		//f32 good enough for view matrix
+		glam::Mat4::from_translation(pos)*glam::Mat4::from_euler(glam::EulerRot::YXZ,angles.x,angles.y,0f32)
+	}
 
-	pub fn to_uniform_data(&self,view_inv:glam::Mat4)->[f32;16*4]{
+	pub fn to_uniform_data(&self,pos:glam::Vec3,angles:glam::Vec2)->[f32;16*4]{
 		let proj=self.proj();
 		let proj_inv=proj.inverse();
+		let view_inv=self.world(pos,angles);
 		let view=view_inv.inverse();
 
 		let mut raw=[0f32; 16 * 4];
@@ -159,6 +162,9 @@ impl GraphicsState{
 	pub fn clear(&mut self){
 		self.models.clear();
 	}
+	pub fn load_user_settings(&mut self,user_settings:&settings::UserSettings){
+		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
+	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
 		//generate texture view per texture
 		let texture_views:HashMap<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
@@ -610,7 +616,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::ClampToEdge,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::MipmapFilterMode::Linear,
+			mipmap_filter:wgpu::FilterMode::Linear,
 			..Default::default()
 		});
 		let repeat_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
@@ -620,7 +626,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::Repeat,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::MipmapFilterMode::Linear,
+			mipmap_filter:wgpu::FilterMode::Linear,
 			anisotropy_clamp:16,
 			..Default::default()
 		});
@@ -628,7 +634,7 @@ impl GraphicsState{
 		// Create the render pipeline
 		let shader=device.create_shader_module(wgpu::ShaderModuleDescriptor{
 			label:None,
-			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../shaders/shader.wgsl"))),
+			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../../../strafe-client/src/shader.wgsl"))),
 		});
 
 		//load textures
@@ -656,10 +662,10 @@ impl GraphicsState{
 				wgpu::TextureFormat::Astc{
 					block:AstcBlock::B4x4,
 					channel:AstcChannel::UnormSrgb,
-				}=>&include_bytes!("../images/astc.dds")[..],
-				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../images/etc2.dds")[..],
-				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../images/bc1.dds")[..],
-				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../images/bgra.dds")[..],
+				}=>&include_bytes!("../../../strafe-client/images/astc.dds")[..],
+				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../../../strafe-client/images/etc2.dds")[..],
+				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../../../strafe-client/images/bc1.dds")[..],
+				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../../../strafe-client/images/bgra.dds")[..],
 				_=>unreachable!(),
 			};
 
@@ -702,7 +708,7 @@ impl GraphicsState{
 
 		//squid
 		let squid_texture_view={
-			let bytes=include_bytes!("../images/squid.dds");
+			let bytes=include_bytes!("../../../strafe-client/images/squid.dds");
 
 			let image=ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
 
@@ -748,7 +754,7 @@ impl GraphicsState{
 				&skybox_texture_bind_group_layout,
 				&model_bind_group_layout,
 			],
-			immediate_size:0,
+			push_constant_ranges:&[],
 		});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
@@ -756,7 +762,7 @@ impl GraphicsState{
 				&camera_bind_group_layout,
 				&skybox_texture_bind_group_layout,
 			],
-			immediate_size:0,
+			push_constant_ranges:&[],
 		});
 
 		// Create the render pipelines
@@ -787,7 +793,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
+			multiview:None,
 			cache:None,
 		});
 		let model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
@@ -822,12 +828,12 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
+			multiview:None,
 			cache:None,
 		});
 
 		let camera=GraphicsCamera::default();
-		let camera_uniforms=camera.to_uniform_data(view_inv(glam::Vec3::ZERO,glam::Vec2::ZERO));
+		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
 		let camera_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
 			label:Some("Camera"),
 			contents:bytemuck::cast_slice(&camera_uniforms),
@@ -874,7 +880,7 @@ impl GraphicsState{
 			camera_buf,
 			models:Vec::new(),
 			depth_view,
-			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
+			staging_belt:wgpu::util::StagingBelt::new(0x100),
 			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
@@ -884,31 +890,35 @@ impl GraphicsState{
 		&mut self,
 		device:&wgpu::Device,
 		config:&wgpu::SurfaceConfiguration,
-		fov:glam::Vec2,
+		user_settings:&settings::UserSettings,
 	){
 		self.depth_view=Self::create_depth_texture(config,device);
 		self.camera.screen_size=glam::uvec2(config.width,config.height);
-		self.camera.fov=fov;
+		self.load_user_settings(user_settings);
 	}
 	pub fn render(
 		&mut self,
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		camera:glam::Mat4,
+		frame_state:session::FrameState,
 	){
 		//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
 
 		let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
 
 		// update rotation
-		let camera_uniforms=self.camera.to_uniform_data(camera);
+		let camera_uniforms=self.camera.to_uniform_data(
+			frame_state.body.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
+			frame_state.camera.simulate_move_angles(glam::IVec2::ZERO)
+		);
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,
 				&self.camera_buf,
 				0,
 				wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
+				device,
 			)
 			.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
 		//This code only needs to run when the uniforms change
@@ -955,7 +965,6 @@ impl GraphicsState{
 				}),
 				timestamp_writes:Default::default(),
 				occlusion_query_set:Default::default(),
-				multiview_mask:None,
 			});
 
 			rpass.set_bind_group(0,&self.bind_groups.camera,&[]);

engine/graphics/src/lib.rs

@@ -1,3 +1,2 @@
 pub mod model;
-pub mod setup;
 pub mod graphics;

engine/graphics/src/setup.rs

@@ -1,112 +0,0 @@
-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 mod step1{
-	pub fn create_instance()->wgpu::Instance{
-		Default::default()
-	}
-}
-
-pub mod step2{
-	pub fn create_surface<'window>(instance:&wgpu::Instance,target:impl Into<wgpu::SurfaceTarget<'window>>)->Result<wgpu::Surface<'window>,wgpu::CreateSurfaceError>{
-		instance.create_surface(target)
-	}
-}
-
-pub mod step3{
-	pub async fn pick_adapter(instance:&wgpu::Instance,surface:&wgpu::Surface<'_>)->Option<wgpu::Adapter>{
-		let backends=wgpu::Backends::from_env().unwrap_or_default();
-		//TODO: prefer adapter that implements optional features
-		//let optional_features=optional_features();
-		let required_features=super::required_features();
-		let required_downlevel_capabilities=super::required_downlevel_capabilities();
-
-		//no helper function smh gotta write it myself
-		let adapters=instance.enumerate_adapters(backends).await;
-
-		let adapter=adapters.into_iter()
-			// reverse because we want to select adapters that appear first in ties,
-			// and max_by_key selects the last equal element in the iterator.
-			.rev()
-			.filter(|adapter|
-				adapter.is_surface_supported(surface)
-				&&adapter.features().contains(required_features)
-				&&{
-					let downlevel_capabilities=adapter.get_downlevel_capabilities();
-					downlevel_capabilities.shader_model>=required_downlevel_capabilities.shader_model
-					&&downlevel_capabilities.flags.contains(required_downlevel_capabilities.flags)
-				}
-			)
-			.max_by_key(|adapter|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_info=adapter.get_info();
-		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
-
-		Some(adapter)
-	}
-}
-
-pub mod step4{
-	pub async fn request_device(adapter:&wgpu::Adapter)->(wgpu::Device,wgpu::Queue){
-		let optional_features=super::optional_features();
-		let required_features=super::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=crate::graphics::required_limits().using_resolution(adapter.limits());
-
-		let (device, queue)=adapter
-			.request_device(
-				&wgpu::DeviceDescriptor{
-					label:None,
-					required_features:(optional_features&adapter.features())|required_features,
-					required_limits:needed_limits,
-					memory_hints:wgpu::MemoryHints::Performance,
-					trace:wgpu::Trace::Off,
-					experimental_features:wgpu::ExperimentalFeatures::disabled(),
-				},
-			).await
-			.expect("Unable to find a suitable GPU adapter!");
-
-		(
-			device,
-			queue,
-		)
-	}
-}
-
-pub mod step5{
-	pub fn configure_surface(
-		adapter:&wgpu::Adapter,
-		device:&wgpu::Device,
-		surface:&wgpu::Surface<'_>,
-		(width,height):(u32,u32),
-	)->wgpu::SurfaceConfiguration{
-		let mut config=surface
-			.get_default_config(adapter, width, 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;
-		surface.configure(device,&config);
-
-		config
-	}
-}

engine/physics/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "strafesnet_physics"
-version = "0.0.1"
+version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 arrayvec = "0.7.6"
-glam.workspace = true
+glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common.workspace = true
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 
 [lints]
 workspace = true

engine/physics/src/body.rs

@@ -2,18 +2,12 @@ use strafesnet_common::aabb;
 use strafesnet_common::integer::{self,vec3,Time,Planar64,Planar64Vec3};
 #[derive(Clone,Copy,Debug,Hash)]
 pub struct Body<T>{
-	pub position:Planar64Vec3,
-	pub velocity:Planar64Vec3,
-	pub time:Time<T>,
+	pub position:Planar64Vec3,//I64 where 2^32 = 1 u
+	pub velocity:Planar64Vec3,//I64 where 2^32 = 1 u/s
+	pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
+	pub time:Time<T>,//nanoseconds x xxxxD!
 }
-#[derive(Clone,Copy,Debug,Hash)]
-pub struct Trajectory<T>{
-	pub position:Planar64Vec3,
-	pub velocity:Planar64Vec3,
-	pub acceleration:Planar64Vec3,
-	pub time:Time<T>,
-}
-impl<T> std::ops::Neg for Trajectory<T>{
+impl<T> std::ops::Neg for Body<T>{
 	type Output=Self;
 	fn neg(self)->Self::Output{
 		Self{
@@ -24,10 +18,10 @@ impl<T> std::ops::Neg for Trajectory<T>{
 		}
 	}
 }
-impl<T:Copy> std::ops::Neg for &Trajectory<T>{
-	type Output=Trajectory<T>;
+impl<T:Copy> std::ops::Neg for &Body<T>{
+	type Output=Body<T>;
 	fn neg(self)->Self::Output{
-		Trajectory{
+		Body{
 			position:self.position,
 			velocity:-self.velocity,
 			acceleration:self.acceleration,
@@ -38,32 +32,6 @@ impl<T:Copy> std::ops::Neg for &Trajectory<T>{
 
 impl<T> Body<T>
 	where Time<T>:Copy,
-{
-	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),Time::ZERO);
-	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,time:Time<T>)->Self{
-		Self{
-			position,
-			velocity,
-			time,
-		}
-	}
-	pub const fn with_acceleration(self,acceleration:Planar64Vec3)->Trajectory<T>{
-		let Body{
-			position,
-			velocity,
-			time,
-		}=self;
-		Trajectory{
-			position,
-			velocity,
-			acceleration,
-			time,
-		}
-	}
-}
-
-impl<T> Trajectory<T>
-	where Time<T>:Copy,
 {
 	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),vec3::zero(),Time::ZERO);
 	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3,time:Time<T>)->Self{
@@ -74,14 +42,13 @@ impl<T> Trajectory<T>
 			time,
 		}
 	}
-	pub fn relative_to(&self,trj0:&Self,time:Time<T>)->Self{
+	pub const fn relative_to<'a>(&'a self,body0:&'a Body<T>)->VirtualBody<'a,T>{
 		//(p0,v0,a0,t0)
 		//(p1,v1,a1,t1)
-		Trajectory::new(
-			self.extrapolated_position(time)-trj0.extrapolated_position(time),
-			self.extrapolated_velocity(time)-trj0.extrapolated_velocity(time),
-			self.acceleration-trj0.acceleration,
-			time)
+		VirtualBody{
+			body0,
+			body1:self,
+		}
 	}
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
@@ -93,12 +60,10 @@ impl<T> Trajectory<T>
 		let dt=time-self.time;
 		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().clamp_1())
 	}
-	pub fn extrapolated_body(&self,time:Time<T>)->Body<T>{
-		Body::new(
-			self.extrapolated_position(time),
-			self.extrapolated_velocity(time),
-			time,
-		)
+	pub fn advance_time(&mut self,time:Time<T>){
+		self.position=self.extrapolated_position(time);
+		self.velocity=self.extrapolated_velocity(time);
+		self.time=time;
 	}
 	pub fn extrapolated_position_ratio_dt<Num,Den,N1,D1,N2,N3,D2,N4,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
 		where
@@ -136,12 +101,10 @@ impl<T> Trajectory<T>
 		// a*dt + v
 		self.acceleration.map(|elem|(dt*elem).divide().clamp())+self.velocity
 	}
-	pub fn extrapolated_body_ratio_dt(&self,dt:crate::model::GigaTime)->Body<T>{
-		Body::new(
-			self.extrapolated_position_ratio_dt(dt),
-			self.extrapolated_velocity_ratio_dt(dt),
-			self.time+dt.into(),
-		)
+	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
+		self.position=self.extrapolated_position_ratio_dt(dt);
+		self.velocity=self.extrapolated_velocity_ratio_dt(dt);
+		self.time+=dt.into();
 	}
 	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
 		if self.velocity==vec3::zero(){
@@ -181,12 +144,28 @@ impl<T> Trajectory<T>
 
 }
 impl<T> std::fmt::Display for Body<T>{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"p({}) v({}) t({})",self.position,self.velocity,self.time)
-	}
-}
-impl<T> std::fmt::Display for Trajectory<T>{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"p({}) v({}) a({}) t({})",self.position,self.velocity,self.acceleration,self.time)
 	}
 }
+
+pub struct VirtualBody<'a,T>{
+	body0:&'a Body<T>,
+	body1:&'a Body<T>,
+}
+impl<T> VirtualBody<'_,T>
+	where Time<T>:Copy,
+{
+	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
+		self.body1.extrapolated_position(time)-self.body0.extrapolated_position(time)
+	}
+	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
+		self.body1.extrapolated_velocity(time)-self.body0.extrapolated_velocity(time)
+	}
+	pub fn acceleration(&self)->Planar64Vec3{
+		self.body1.acceleration-self.body0.acceleration
+	}
+	pub fn body(&self,time:Time<T>)->Body<T>{
+		Body::new(self.extrapolated_position(time),self.extrapolated_velocity(time),self.acceleration(),time)
+	}
+}

engine/physics/src/face_crawler.rs

@@ -1,21 +1,20 @@
-use crate::model::{into_giga_time,GigaTime};
-use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3,Planar64Vec3};
-use crate::physics::{Time,Trajectory};
-use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
+use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
+use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
+use crate::physics::{Time,Body};
 
 use core::ops::Bound;
 
-enum Transition<M:MeshTopology>{
+enum Transition<M:MeshQuery>{
 	Miss,
 	Next(FEV<M>,GigaTime),
 	Hit(M::Face,GigaTime),
 }
 
-pub enum CrawlResult<M:MeshTopology>{
+pub enum CrawlResult<M:MeshQuery>{
 	Miss(FEV<M>),
 	Hit(M::Face,GigaTime),
 }
-impl<M:MeshTopology> CrawlResult<M>{
+impl<M:MeshQuery> CrawlResult<M>{
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,
@@ -65,18 +64,17 @@ where
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64Vec3,Direction=Planar64Vec3>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
-		M::DirectedEdge:Copy,
 		M::Vert:Copy,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
 		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition(&self,mesh:&M,trajectory:&Trajectory,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
+	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -88,29 +86,29 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 				let (n,d)=mesh.face_nd(face_id);
 				//TODO: use higher precision d value?
 				//use the mesh transform translation instead of baking it into the d value.
-				for dt in Fixed::<4,128>::zeroes2((n.dot(trajectory.position)-d)*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
-					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+					if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 						upper_bound=Bound::Included(dt);
 						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				mesh.for_each_face_edge(face_id,|directed_edge_id|{
+				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
 					let edge_n=mesh.directed_edge_n(directed_edge_id);
 					let n=n.cross(edge_n);
 					let &[v0,v1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
 					//WARNING: d is moved out of the *2 block because of adding two vertices!
 					//WARNING: precision is swept under the rug!
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(trajectory.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
-				});
+				}
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
@@ -119,15 +117,15 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 				let &[ev0,ev1]=edge_verts.as_ref();
 				let (v0,v1)=(mesh.vert(ev0),mesh.vert(ev1));
 				let edge_n=v1-v0;
-				let delta_pos=trajectory.position*2-(v0+v1);
+				let delta_pos=body.position*2-(v0+v1);
 				for (i,&edge_face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=mesh.face_nd(edge_face_id).0;
 					//edge_n gets parity from the order of edge_faces
 					let n=face_n.cross(edge_n)*((i as i64)*2-1);
 					//WARNING yada yada d *2
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
@@ -138,8 +136,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 				for (i,&vert_id) in edge_verts.as_ref().iter().enumerate(){
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
-					for dt in Fixed::<2,64>::zeroes2((n.dot(trajectory.position-mesh.vert(vert_id)))*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
@@ -151,28 +149,28 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64V
 			},
 			&FEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
+				for &directed_edge_id in mesh.vert_edges(vert_id).as_ref(){
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					let n=-mesh.directed_edge_n(directed_edge_id);
-					for dt in Fixed::<2,64>::zeroes2((n.dot(trajectory.position-mesh.vert(vert_id)))*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
-				});
+				}
 				//if none:
 			},
 		}
 		best_transition
 	}
-	pub fn crawl(mut self,mesh:&M,trajectory:&Trajectory,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
-		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,trajectory.time));
-		let upper_bound=upper_bound.map(|&t|into_giga_time(t,trajectory.time));
+	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
+		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
 		for _ in 0..20{
-			match self.next_transition(mesh,trajectory,lower_bound,upper_bound){
+			match self.next_transition(mesh,relative_body,lower_bound,upper_bound){
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/lib.rs

@@ -1,7 +1,5 @@
 mod body;
 mod face_crawler;
-mod mesh_query;
-mod minkowski;
 mod model;
 mod push_solve;
 mod minimum_difference;

engine/physics/src/mesh_query.rs

@@ -1,56 +0,0 @@
-pub enum FEV<M:MeshTopology>{
-	Vert(M::Vert),
-	Edge(M::Edge),
-	Face(M::Face),
-}
-
-pub trait UndirectedEdge{
-	type DirectedEdge:DirectedEdge<UndirectedEdge=Self>;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge;
-}
-pub trait DirectedEdge{
-	type UndirectedEdge:UndirectedEdge<DirectedEdge=Self>;
-	fn as_undirected(self)->Self::UndirectedEdge;
-	fn parity(&self)->bool;
-	fn reverse(self)->Self
-		where
-			Self:Sized
-	{
-		let parity=!self.parity();
-		self.as_undirected().as_directed(parity)
-	}
-}
-
-pub trait MeshTopology{
-	type Face;
-	type Edge:UndirectedEdge<DirectedEdge=Self::DirectedEdge>;
-	type DirectedEdge:DirectedEdge<UndirectedEdge=Self::Edge>;
-	type Vert;
-	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge));
-	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face));
-	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>;
-	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>;
-	#[expect(unused)]
-	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert));
-	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge));
-}
-
-// Make face_nd d value relative
-// euclidean point?
-// Simplex physics
-// Directed edge necessary?
-// recursive for_each function calls
-// define faces from vertices (Fixed<2> vs Fixed<3>)
-pub trait MeshQuery:MeshTopology{
-	type Position;
-	type Direction;
-	type Normal;
-	type Offset;
-	fn vert(&self,vert_id:Self::Vert)->Self::Position;
-	fn farthest_vert(&self,dir:Self::Direction)->Self::Vert;
-	/// This must return a point inside the mesh.
-	fn hint_point(&self)->Self::Position;
-	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
-	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction;
-	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction;
-}

engine/physics/src/minimum_difference.rs

@@ -2,9 +2,7 @@ use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 
-use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
-// TODO: remove mesh invert
-use crate::minkowski::{MinkowskiMesh,MinkowskiVert};
+use crate::model::{DirectedEdge,FEV,MeshQuery};
 
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
@@ -46,7 +44,7 @@ local function absDet(r, u, v, w)
 end
 */
 impl<Vert> Simplex2_4<Vert>{
-	fn det_is_zero<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M)->bool{
+	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
 		match self{
 			Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
@@ -100,44 +98,11 @@ const fn choose_any_direction()->Planar64Vec3{
 	vec3::X
 }
 
-fn narrow_dir2(dir:Vector3<Fixed<2,64>>)->Planar64Vec3{
-	if dir==vec3::zero(){
-		return dir.narrow_1().unwrap();
-	}
-	let x=dir.x.as_bits().unsigned_abs().bits();
-	let y=dir.y.as_bits().unsigned_abs().bits();
-	let z=dir.z.as_bits().unsigned_abs().bits();
-	let big=x.max(y).max(z);
-	const MAX_BITS:u32=64+31;
-	if MAX_BITS<big{
-		dir>>(big-MAX_BITS)
-	}else{
-		dir
-	}.narrow_1().unwrap()
-}
-fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
-	if dir==vec3::zero(){
-		return dir.narrow_1().unwrap();
-	}
-	let x=dir.x.as_bits().unsigned_abs().bits();
-	let y=dir.y.as_bits().unsigned_abs().bits();
-	let z=dir.z.as_bits().unsigned_abs().bits();
-	let big=x.max(y).max(z);
-	const MAX_BITS:u32=96+31;
-	if MAX_BITS<big{
-		dir>>(big-MAX_BITS)
-	}else{
-		dir
-	}.narrow_1().unwrap()
-}
-
-fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce1<M:MeshQuery>(
 	[v0]:Simplex<1,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>
-	where M::Vert:Copy,
-{
+)->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
 	let p0=mesh.vert(v0);
@@ -162,14 +127,11 @@ fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
 }
 
 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce2<M:MeshQuery>(
 	[v0,v1]:Simplex<2,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>
-	where
-		M::Vert:Copy
-{
+)->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -201,7 +163,7 @@ fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
 		// -- modify the direction to take into account a0R and b0R
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -222,14 +184,11 @@ fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
 }
 
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce3<M:MeshQuery>(
 	[v0,mut v1,v2]:Simplex<3,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>
-	where
-		M::Vert:Copy
-{
+)->Reduced<M::Vert>{
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -270,7 +229,7 @@ fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
-			dir:narrow_dir2(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 		};
 	}
@@ -304,14 +263,14 @@ fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 		if direction==vec3::zero(){
 			// direction = uv
 			return Reduced{
-				dir:narrow_dir2(uv),
+				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}
 
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -322,7 +281,7 @@ fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 	if dir==vec3::zero(){
 		// direction = uv
 		return Reduced{
-			dir:narrow_dir2(uv),
+			dir:uv.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex1([v0]),
 		};
 	}
@@ -334,14 +293,11 @@ fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 }
 
 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
+fn reduce4<M:MeshQuery>(
 	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduce<M::Vert>
-	where
-		M::Vert:Copy
-{
+)->Reduce<M::Vert>{
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -378,8 +334,8 @@ fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 
 	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
 	if !pv_w.div_sign(uv_w).is_negative()
-	 &&!up_w.div_sign(uv_w).is_negative()
-	 &&!uv_p.div_sign(uv_w).is_negative(){
+	 ||!up_w.div_sign(uv_w).is_negative()
+	 ||!uv_p.div_sign(uv_w).is_negative(){
 		// origin is contained, this is a positive detection
 		// local direction = Vector3.new(0, 0, 0)
 		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
@@ -407,6 +363,8 @@ fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
+		}else{
+			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -419,6 +377,8 @@ fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}
 
@@ -435,15 +395,17 @@ fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 	if !uv_up.is_negative()&&!uv_pv.is_negative(){
 		// local direction = uvw < 0 and uv or -uv
 		// return direction, a0, a1, b0, b1, c0, c1
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			return Reduce::Reduced(Reduced{
+				dir:uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:-uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}
 	}
 
 	// local u_u = u:Dot(u)
@@ -475,20 +437,22 @@ fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 		if direction==vec3::zero(){
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
-			let dir=if uv_w.is_negative(){
-				narrow_dir2(uv)
+			if uv_w.is_negative(){
+				return Reduce::Reduced(Reduced{
+					dir:uv.narrow_1().unwrap(),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
 			}else{
-				narrow_dir2(-uv)
-			};
-			return Reduce::Reduced(Reduced{
-				dir,
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			});
+				return Reduce::Reduced(Reduced{
+					dir:-uv.narrow_1().unwrap(),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
 		}
 
 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		});
 	}
@@ -498,15 +462,17 @@ fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			return Reduce::Reduced(Reduced{
+				dir:uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex1([v0]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:-uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
 	}
 
 	// return direction, a0, a1
@@ -527,10 +493,7 @@ enum Reduce<Vert>{
 }
 
 impl<Vert> Simplex2_4<Vert>{
-	fn reduce<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>
-		where
-			M::Vert:Copy
-	{
+	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
 		match self{
 			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
 			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
@@ -539,17 +502,35 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
+pub fn contains_point<M:MeshQuery>(mesh:&M,point:Planar64Vec3)->bool{
+	const ENABLE_FAST_FAIL:bool=true;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,M>(&-mesh,point,
+		// on_exact
+		|is_intersecting,_simplex|{
+			is_intersecting
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			true
+		},
+		// fast_fail value
+		||false
+	)
+}
+
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition<Vert>{
 	Done,//found closest vert, no edges are better
 	Vert(Vert),//transition to vert
 }
-enum EV<M:MeshTopology>{
+enum EV<M:MeshQuery>{
 	Vert(M::Vert),
-	Edge(M::Edge),
+	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
 }
-impl<M:MeshTopology> From<EV<M>> for FEV<M>{
+impl<M:MeshQuery> From<EV<M>> for FEV<M>{
 	fn from(value:EV<M>)->Self{
 		match value{
 			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
@@ -569,7 +550,7 @@ struct ThickPlane{
 	epsilon:Fixed<3,96>,
 }
 impl ThickPlane{
-	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let p2=mesh.vert(v2);
@@ -593,7 +574,7 @@ struct ThickLine{
 	epsilon:Fixed<4,128>,
 }
 impl ThickLine{
-	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let point=p0;
@@ -616,14 +597,10 @@ struct EVFinder<'a,M,C>{
 	best_distance_squared:Fixed<2,64>,
 }
 
-impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
-	where
-		M::Vert:Copy,
-		M::DirectedEdge:Copy,
-{
+impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
 		let mut best_transition=Transition::Done;
-		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
+		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
 			//test if this edge's opposite vertex closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			//select opposite vertex
@@ -636,14 +613,14 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 				best_transition=Transition::Vert(test_vert_id);
 				self.best_distance_squared=distance_squared;
 			}
-		});
+		}
 		best_transition
 	}
 	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
 		let mut best_transition=EV::Vert(vert_id);
 		let vert_pos=self.mesh.vert(vert_id);
 		let diff=point-vert_pos;
-		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
+		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
 			//test if this edge is closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
@@ -664,13 +641,10 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 					self.best_distance_squared=distance_squared;
 				}
 			}
-		});
+		}
 		best_transition
 	}
-	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>
-		where
-			M::Vert:Copy
-	{
+	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
 		loop{
 			match self.next_transition_vert(vert_id,point){
 				Transition::Done=>return self.final_ev(vert_id,point),
@@ -679,12 +653,8 @@ impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
 		}
 	}
 }
-/// This function hops along parallel vertices until it finds the EV which contains the closest point to `point`.
-fn crawl_to_closest_ev<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>
-	where
-		M::Vert:Copy,
-		M::DirectedEdge:Copy,
-{
+/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
+fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
 	// but it doesn't matter, we will get there regardless.
@@ -701,8 +671,8 @@ fn crawl_to_closest_ev<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,simplex:Simpl
 	finder.crawl_boundaries(vert_id,point)
 }
 
-/// This function hops along connected vertices until it finds the FEV which contains the closest point to `point`.
-fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiVert>,point:Planar64Vec3)->FEV::<MinkowskiMesh<'a>>{
+/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
+fn crawl_to_closest_fev<M:MeshQuery>(mesh:&M,simplex:Simplex<3,M::Vert>,point:Planar64Vec3)->FEV::<M>{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
 	// but it doesn't matter, we will get there regardless.
@@ -749,10 +719,10 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 	}
 }
 
-pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+pub fn closest_fev_not_inside<M:MeshQuery>(mesh:&M,point:Planar64Vec3)->Option<FEV<M>>{
 	const ENABLE_FAST_FAIL:bool=false;
 	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+	minimum_difference::<ENABLE_FAST_FAIL,_,M>(&-mesh,point,
 		// on_exact
 		|is_intersecting,simplex|{
 			if is_intersecting{
@@ -765,7 +735,11 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 				Simplex1_3::Simplex2([v0,v1])=>{
 					// invert
 					let (v0,v1)=(-v0,-v1);
-					crawl_to_closest_ev(mesh,[v0,v1],point).into()
+					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
+					if !matches!(ev,EV::Edge(_)){
+						println!("I can't believe it's not an edge!");
+					}
+					ev.into()
 				},
 				Simplex1_3::Simplex3([v0,v1,v2])=>{
 					// invert
@@ -773,7 +747,11 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 					// Shimmy to the side until you find a face that contains the closest point
 					// it's ALWAYS representable as a face, but this algorithm may
 					// return E or V in edge cases but I don't think that will break the face crawler
-					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
+					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
+					if !matches!(fev,FEV::Face(_)){
+						println!("I can't believe it's not a face!");
+					}
+					fev
 				},
 			})
 		},
@@ -789,39 +767,18 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 	)
 }
 
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
-	const ENABLE_FAST_FAIL:bool=true;
-	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
-		// on_exact
-		|is_intersecting,_simplex|{
-			is_intersecting
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			true
-		},
-		// fast_fail value
-		||false
-	)
-}
-
 // local function minimumDifference(
 // 	queryP, radiusP,
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar64Vec3,Direction=Planar64Vec3>>(
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
 	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
 	on_fast_fail:impl FnOnce()->T,
-)->T
-	where
-		M::Vert:Copy
-{
+)->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)
@@ -884,40 +841,4 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar6
 	}
 }
 
-#[cfg(test)]
-mod test{
-	use super::*;
-    use crate::model::{PhysicsMesh,PhysicsMeshView};
-
-    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
-		const ENABLE_FAST_FAIL:bool=true;
-		// TODO: remove mesh negation
-		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
-			// on_exact
-			|is_intersecting,_simplex|{
-				is_intersecting
-			},
-			// on_escape
-			|_simplex|{
-				// intersection is guaranteed at this point
-				true
-			},
-			// fast_fail value
-			||false
-		)
-	}
-
-	#[test]
-	fn test_cube_points(){
-		let mesh=PhysicsMesh::unit_cube();
-		let mesh_view=mesh.complete_mesh_view();
-		for x in -2..=2{
-			for y in -2..=2{
-				for z in -2..=2{
-					let point=vec3::int(x,y,z)>>1;
-					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
-				}
-			}
-		}
-	}
-}
+// TODO: unit tests

engine/physics/src/minkowski.rs

@@ -1,407 +0,0 @@
-use core::ops::{Bound,RangeBounds};
-
-use strafesnet_common::integer::{Planar64Vec3,Ratio,Fixed,vec3::Vector3};
-use crate::model::into_giga_time;
-use crate::model::{SubmeshVertId,SubmeshEdgeId,SubmeshDirectedEdgeId,SubmeshFaceId,TransformedMesh,GigaTime};
-use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
-use crate::physics::{Time,Trajectory};
-
-struct AsRefHelper<T>(T);
-impl<T> AsRef<T> for AsRefHelper<T>{
-	fn as_ref(&self)->&T{
-		&self.0
-	}
-}
-
-//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
-//(face,vertex)
-//(edge,edge)
-//(vertex,face)
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
-pub enum MinkowskiVert{
-	VertVert(SubmeshVertId,SubmeshVertId),
-}
-// TODO: remove this
-impl core::ops::Neg for MinkowskiVert{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		match self{
-			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiEdge{
-	VertEdge(SubmeshVertId,SubmeshEdgeId),
-	EdgeVert(SubmeshEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl UndirectedEdge for MinkowskiEdge{
-	type DirectedEdge=MinkowskiDirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge{
-		match self{
-			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
-			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),v1),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiDirectedEdge{
-	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
-	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl DirectedEdge for MinkowskiDirectedEdge{
-	type UndirectedEdge=MinkowskiEdge;
-	fn as_undirected(self)->Self::UndirectedEdge{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
-			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),v1),
-		}
-	}
-	fn parity(&self)->bool{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)
-			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug,Hash)]
-pub enum MinkowskiFace{
-	VertFace(SubmeshVertId,SubmeshFaceId),
-	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
-	FaceVert(SubmeshFaceId,SubmeshVertId),
-	//EdgeFace
-	//FaceEdge
-	//FaceFace
-}
-
-#[derive(Debug)]
-pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
-}
-
-// TODO: remove this
-impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
-	type Output=MinkowskiMesh<'a>;
-	fn neg(self)->Self::Output{
-		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
-	}
-}
-
-impl MinkowskiMesh<'_>{
-	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
-		MinkowskiMesh{
-			mesh0,
-			mesh1,
-		}
-	}
-	pub fn predict_collision_in(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let start_position=match range.start_bound(){
-			Bound::Included(time)=>trajectory.extrapolated_position(*time),
-			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
-			Bound::Unbounded=>trajectory.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		//continue forwards along the body parabola
-		fev.crawl(self,trajectory,range.start_bound(),range.end_bound()).hit()
-	}
-	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// TODO: handle unbounded collision using infinity fev
-		let start_position=match upper_bound{
-			Bound::Included(time)=>trajectory.extrapolated_position(*time),
-			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
-			Bound::Unbounded=>trajectory.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		// swap and negate bounds to do a time inversion
-		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
-		let time_reversed_trajectory=-trajectory;
-		//continue backwards along the body parabola
-		fev.crawl(self,&time_reversed_trajectory,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time))
-	}
-	pub fn predict_collision_face_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
-		// TODO: make better
-		use crate::face_crawler::{low,upp};
-		//no algorithm needed, there is only one state and two cases (Edge,None)
-		//determine when it passes an edge ("sliding off" case)
-		let start_time=range.start_bound().map(|&t|(t-trajectory.time).to_ratio());
-		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.time));
-		let mut best_edge=None;
-		let face_n=self.face_nd(contact_face_id).0;
-		self.for_each_face_edge(contact_face_id,|directed_edge_id|{
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//f x e points in
-			let n=face_n.cross(edge_n);
-			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-			let d=n.dot(self.vert(v0)+self.vert(v1));
-			//WARNING! d outside of *2
-			//WARNING: truncated precision
-			//wrap for speed
-			for dt in Fixed::<4,128>::zeroes2(((n.dot(trajectory.position))*2-d).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=Bound::Included(dt);
-					best_edge=Some((directed_edge_id,dt));
-					break;
-				}
-			}
-		});
-		best_edge
-	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		crate::minimum_difference::contains_point(self,point)
-	}
-}
-impl MeshQuery for MinkowskiMesh<'_>{
-	type Direction=Planar64Vec3;
-	type Position=Planar64Vec3;
-	type Normal=Vector3<Fixed<3,96>>;
-	type Offset=Fixed<4,128>;
-	// TODO: relative d
-	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				let (n,d)=self.mesh1.face_nd(f1);
-				(-n,d-n.dot(self.mesh0.vert(v0)))
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let edge0_n=self.mesh0.edge_n(e0);
-				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				let n=edge0_n.cross(edge1_n);
-				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
-				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				let (n,d)=self.mesh0.face_nd(f0);
-				(n,d-n.dot(self.mesh1.vert(v1)))
-			},
-		}
-	}
-	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				self.mesh0.vert(v0)-self.mesh1.vert(v1)
-			},
-		}
-	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh0.hint_point()-self.mesh1.hint_point()
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
-	}
-	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
-	}
-	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
-}
-impl MeshTopology for MinkowskiMesh<'_>{
-	type Face=MinkowskiFace;
-	type Edge=MinkowskiEdge;
-	type DirectedEdge=MinkowskiDirectedEdge;
-	type Vert=MinkowskiVert;
-	fn for_each_vert_edge(&self,vert_id:Self::Vert,mut f:impl FnMut(Self::DirectedEdge)){
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f={
-					let mut faces=Vec::new();
-					self.mesh0.for_each_vert_face(v0,|face|faces.push(face));
-					faces
-				};
-				let v1f={
-					let mut faces=Vec::new();
-					self.mesh1.for_each_vert_face(v1,|face|faces.push(face));
-					faces
-				};
-				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				// scratch vector
-				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
-				face_normals.clone_from(&v0f_n);
-				self.mesh0.for_each_vert_edge(v0,|directed_edge_id|{
-					let n=self.mesh0.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// TODO: there's gotta be a better way to do this
-					// drop faces beyond v0f_n
-					face_normals.truncate(v0f.len());
-					// make a set of faces from mesh0's perspective
-					for face_n in &v1f_n{
-						//add reflected mesh1 faces
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						f(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
-					}
-				});
-				face_normals.clone_from(&v1f_n);
-				self.mesh1.for_each_vert_edge(v1,|directed_edge_id|{
-					let n=self.mesh1.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// drop faces beyond v1f_n
-					face_normals.truncate(v1f.len());
-					// make a set of faces from mesh1's perspective
-					for face_n in &v0f_n{
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						f(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
-					}
-				});
-			},
-		}
-	}
-	fn for_each_vert_face(&self,_vert_id:Self::Vert,_f:impl FnMut(Self::Face)){
-		unimplemented!()
-	}
-	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
-		match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>{
-				//faces are listed backwards from the minkowski mesh
-				let v0e={
-					let mut edges=Vec::new();
-					self.mesh0.for_each_vert_edge(v0,|edge|edges.push(edge));
-					edges
-				};
-				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
-				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
-					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
-					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
-					for &directed_edge_id0 in &v0e{
-						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
-						//must be behind other face.
-						let d=edge_face1_n.dot(edge0_n);
-						if d.is_negative(){
-							let edge0_nn=edge0_n.dot(edge0_n);
-							// Assume not every number is huge
-							// TODO: revisit this
-							let dd=(d*d)/(edge_face1_nn*edge0_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id0);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::VertFace(v0,edge_face_id1),
-						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
-					)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				//tracking index with an external variable because .enumerate() is not available
-				let v1e={
-					let mut edges=Vec::new();
-					self.mesh1.for_each_vert_edge(v1,|edge|edges.push(edge));
-					edges
-				};
-				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
-				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
-					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
-					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
-					for &directed_edge_id1 in &v1e{
-						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
-						let d=edge_face0_n.dot(edge1_n);
-						if d.is_negative(){
-							let edge1_nn=edge1_n.dot(edge1_n);
-							let dd=(d*d)/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id1);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::FaceVert(edge_face_id0,v1),
-						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
-					)
-				}))
-			},
-		}
-	}
-	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
-		AsRefHelper(match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
-				MinkowskiVert::VertVert(v0,vert_id1)
-			),
-			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
-				MinkowskiVert::VertVert(vert_id0,v1)
-			),
-		})
-	}
-	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
-		unimplemented!()
-	}
-	fn for_each_face_edge(&self,face_id:Self::Face,mut f:impl FnMut(Self::DirectedEdge)){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				self.mesh1.for_each_face_edge(f1,|edge_id1|
-					f(MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse()))
-				)
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				//could sort this if ordered edges are needed
-				//probably just need to reverse this list according to parity
-				f(MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)));
-				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0));
-				f(MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)));
-				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1));
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				self.mesh0.for_each_face_edge(f0,|edge_id0|
-					f(MinkowskiDirectedEdge::EdgeVert(edge_id0,v1))
-				)
-			},
-		}
-	}
-}
-
-fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
-	let len=normals.len();
-	for i in 0..len-1{
-		for j in i+1..len{
-			let n=normals[i].cross(normals[j]);
-			let mut d_comp=None;
-			for k in 0..len{
-				if k!=i&&k!=j{
-					let d=n.dot(normals[k]).is_negative();
-					if let &Some(comp)=&d_comp{
-						// This is testing if d_comp*d < 0
-						if comp^d{
-							return true;
-						}
-					}else{
-						d_comp=Some(d);
-					}
-				}
-			}
-		}
-	}
-	return false;
-}
-
-#[test]
-fn test_is_empty_volume(){
-	use strafesnet_common::integer::vec3;
-	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
-	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
-}

engine/physics/src/model.rs

@@ -1,9 +1,11 @@
 use std::collections::{HashSet,HashMap};
+use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
-use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
+
+type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -12,6 +14,20 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 	}
 }
 
+pub trait UndirectedEdge{
+	type DirectedEdge:Copy+DirectedEdge;
+	fn as_directed(&self,parity:bool)->Self::DirectedEdge;
+}
+pub trait DirectedEdge{
+	type UndirectedEdge:Copy+std::fmt::Debug+UndirectedEdge;
+	fn as_undirected(&self)->Self::UndirectedEdge;
+	fn parity(&self)->bool;
+	//this is stupid but may work fine
+	fn reverse(&self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
+		self.as_undirected().as_directed(!self.parity())
+	}
+}
+
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct MeshVertId(u32);
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
@@ -29,13 +45,13 @@ pub struct SubmeshFaceId(u32);
 
 impl UndirectedEdge for SubmeshEdgeId{
 	type DirectedEdge=SubmeshDirectedEdgeId;
-	fn as_directed(self,parity:bool)->SubmeshDirectedEdgeId{
+	fn as_directed(&self,parity:bool)->SubmeshDirectedEdgeId{
 		SubmeshDirectedEdgeId(self.0|((parity as u32)<<(u32::BITS-1)))
 	}
 }
 impl DirectedEdge for SubmeshDirectedEdgeId{
 	type UndirectedEdge=SubmeshEdgeId;
-	fn as_undirected(self)->SubmeshEdgeId{
+	fn as_undirected(&self)->SubmeshEdgeId{
 		SubmeshEdgeId(self.0&!(1<<(u32::BITS-1)))
 	}
 	fn parity(&self)->bool{
@@ -43,6 +59,14 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 	}
 }
 
+//Vertex <-> Edge <-> Face -> Collide
+#[derive(Debug)]
+pub enum FEV<M:MeshQuery>{
+	Face(M::Face),
+	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+	Vert(M::Vert),
+}
+
 //use Unit32 #[repr(C)] for map files
 #[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 struct Face{
@@ -51,23 +75,45 @@ struct Face{
 }
 #[derive(Debug)]
 struct Vert(Planar64Vec3);
+pub trait MeshQuery{
+	type Face:Copy;
+	type Edge:Copy+DirectedEdge;
+	type Vert:Copy;
+	// Vertex must be Planar64Vec3 because it represents an actual position
+	type Normal;
+	type Offset;
+	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::Edge)->Planar64Vec3{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+	/// This must return a point inside the mesh.
+	fn hint_point(&self)->Planar64Vec3;
+	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
+	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
+	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
+	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
+	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Face;2]>;
+	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Vert;2]>;
+	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
+	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
+}
 #[derive(Debug)]
 struct FaceRefs{
-	// I didn't write it down, but I assume the edges are directed
-	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
-	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//start, end
+	verts:[SubmeshVertId;2],//bottom, top
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
-	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -395,8 +441,9 @@ pub struct PhysicsMeshView<'a>{
 	topology:&'a PhysicsMeshTopology,
 }
 impl MeshQuery for PhysicsMeshView<'_>{
-	type Position=Planar64Vec3;
-	type Direction=Planar64Vec3;
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -424,37 +471,20 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
 		self.data.verts[vert_idx].0
 	}
-	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
+	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.topology.face_topology[face_id.get() as usize].edges.as_slice()
 	}
-	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
-}
-impl MeshTopology for PhysicsMeshView<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshEdgeId;
-	type DirectedEdge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
-	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
-		self.topology.vert_topology[vert_id.get() as usize].edges.iter().copied().for_each(f);
-	}
-	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
-		self.topology.vert_topology[vert_id.get() as usize].faces.iter().copied().for_each(f);
-	}
-	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
+	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].faces)
 	}
-	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
+	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].verts)
 	}
-	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
-		unimplemented!()
+	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.topology.vert_topology[vert_id.get() as usize].edges.as_slice()
 	}
-	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
-		self.topology.face_topology[face_id.get() as usize].edges.iter().copied().for_each(f);
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
+		self.topology.vert_topology[vert_id.get() as usize].faces.as_slice()
 	}
 }
 
@@ -494,8 +524,9 @@ impl TransformedMesh<'_>{
 	}
 }
 impl MeshQuery for TransformedMesh<'_>{
-	type Direction=Planar64Vec3;
-	type Position=Planar64Vec3;
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -523,47 +554,387 @@ impl MeshQuery for TransformedMesh<'_>{
 			.unwrap().0 as u32
 		)
 	}
-	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
-	}
-	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
-}
-impl MeshTopology for TransformedMesh<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshEdgeId;
-	type DirectedEdge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
 	#[inline]
-	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
-		self.view.for_each_vert_edge(vert_id,f)
+	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.view.face_edges(face_id)
 	}
 	#[inline]
-	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
-		self.view.for_each_vert_face(vert_id,f)
-	}
-	#[inline]
-	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
+	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
 		self.view.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
+	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
 		self.view.edge_verts(edge_id)
 	}
-	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert)){
-		self.view.for_each_face_vert(face_id,f)
+	#[inline]
+	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.view.vert_edges(vert_id)
 	}
 	#[inline]
-	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
-		self.view.for_each_face_edge(face_id,f)
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
+		self.view.vert_faces(vert_id)
 	}
 }
 
+//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
+//(face,vertex)
+//(edge,edge)
+//(vertex,face)
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+pub enum MinkowskiVert{
+	VertVert(SubmeshVertId,SubmeshVertId),
+}
+// TODO: remove this
+impl core::ops::Neg for MinkowskiVert{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		match self{
+			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+pub enum MinkowskiEdge{
+	VertEdge(SubmeshVertId,SubmeshEdgeId),
+	EdgeVert(SubmeshEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl UndirectedEdge for MinkowskiEdge{
+	type DirectedEdge=MinkowskiDirectedEdge;
+	fn as_directed(&self,parity:bool)->Self::DirectedEdge{
+		match self{
+			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(*v0,e1.as_directed(parity)),
+			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),*v1),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+pub enum MinkowskiDirectedEdge{
+	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
+	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl DirectedEdge for MinkowskiDirectedEdge{
+	type UndirectedEdge=MinkowskiEdge;
+	fn as_undirected(&self)->Self::UndirectedEdge{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
+			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
+		}
+	}
+	fn parity(&self)->bool{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(_,e)
+			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Hash)]
+pub enum MinkowskiFace{
+	VertFace(SubmeshVertId,SubmeshFaceId),
+	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
+	FaceVert(SubmeshFaceId,SubmeshVertId),
+	//EdgeFace
+	//FaceEdge
+	//FaceFace
+}
+
+#[derive(Debug)]
+pub struct MinkowskiMesh<'a>{
+	mesh0:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
+}
+
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
 pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	let r=(time-relative_to).to_ratio();
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }
+
+// TODO: remove this
+impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
+	type Output=MinkowskiMesh<'a>;
+	fn neg(self)->Self::Output{
+		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
+	}
+}
+
+impl MinkowskiMesh<'_>{
+	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
+		MinkowskiMesh{
+			mesh0,
+			mesh1,
+		}
+	}
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		//continue forwards along the body parabola
+		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+	}
+	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
+		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// swap and negate bounds to do a time inversion
+		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
+		let infinity_body=-relative_body;
+		//continue backwards along the body parabola
+		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			//no need to test -time<time_limit because of the first step
+			.map(|(face,time)|(face,-time))
+	}
+	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+		// TODO: make better
+		use crate::face_crawler::{low,upp};
+		//no algorithm needed, there is only one state and two cases (Edge,None)
+		//determine when it passes an edge ("sliding off" case)
+		let start_time=range.start_bound().map(|&t|(t-relative_body.time).to_ratio());
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
+		let mut best_edge=None;
+		let face_n=self.face_nd(contact_face_id).0;
+		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//f x e points in
+			let n=face_n.cross(edge_n);
+			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+			let d=n.dot(self.vert(v0)+self.vert(v1));
+			//WARNING! d outside of *2
+			//WARNING: truncated precision
+			//wrap for speed
+			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					best_time=Bound::Included(dt);
+					best_edge=Some((directed_edge_id,dt));
+					break;
+				}
+			}
+		}
+		best_edge
+	}
+	pub fn contains_point(&self,point:Planar64Vec3)->bool{
+		crate::minimum_difference::contains_point(self,point)
+	}
+}
+impl MeshQuery for MinkowskiMesh<'_>{
+	type Face=MinkowskiFace;
+	type Edge=MinkowskiDirectedEdge;
+	type Vert=MinkowskiVert;
+	type Normal=Vector3<Fixed<3,96>>;
+	type Offset=Fixed<4,128>;
+	// TODO: relative d
+	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				let (n,d)=self.mesh1.face_nd(f1);
+				(-n,d-n.dot(self.mesh0.vert(v0)))
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let edge0_n=self.mesh0.edge_n(e0);
+				let edge1_n=self.mesh1.edge_n(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				let n=edge0_n.cross(edge1_n);
+				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
+				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
+				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				let (n,d)=self.mesh0.face_nd(f0);
+				(n,d-n.dot(self.mesh1.vert(v1)))
+			},
+		}
+	}
+	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				self.mesh0.vert(v0)-self.mesh1.vert(v1)
+			},
+		}
+	}
+	fn hint_point(&self)->Planar64Vec3{
+		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				self.mesh1.face_edges(f1).as_ref().iter().map(|&edge_id1|
+					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
+				).collect()
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				//could sort this if ordered edges are needed
+				//probably just need to reverse this list according to parity
+				vec![
+					MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)),
+					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0),
+					MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)),
+					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1),
+				]
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				self.mesh0.face_edges(f0).as_ref().iter().map(|&edge_id0|
+					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
+				).collect()
+			},
+		}
+	}
+	fn edge_faces(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiFace;2]>{
+		match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>{
+				//faces are listed backwards from the minkowski mesh
+				let v0e=self.mesh0.vert_edges(v0);
+				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
+				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
+					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
+					for &directed_edge_id0 in v0e.as_ref(){
+						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
+						//must be behind other face.
+						let d=edge_face1_n.dot(edge0_n);
+						if d.is_negative(){
+							let edge0_nn=edge0_n.dot(edge0_n);
+							// Assume not every number is huge
+							// TODO: revisit this
+							let dd=(d*d)/(edge_face1_nn*edge0_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id0);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::VertFace(v0,edge_face_id1),
+						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
+					)
+				}))
+			},
+			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				//tracking index with an external variable because .enumerate() is not available
+				let v1e=self.mesh1.vert_edges(v1);
+				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
+				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
+					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
+					for &directed_edge_id1 in v1e.as_ref(){
+						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						let d=edge_face0_n.dot(edge1_n);
+						if d.is_negative(){
+							let edge1_nn=edge1_n.dot(edge1_n);
+							let dd=(d*d)/(edge_face0_nn*edge1_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id1);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::FaceVert(edge_face_id0,v1),
+						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
+					)
+				}))
+			},
+		}
+	}
+	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
+		AsRefHelper(match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
+				MinkowskiVert::VertVert(v0,vert_id1)
+			),
+			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
+				MinkowskiVert::VertVert(vert_id0,v1)
+			),
+		})
+	}
+	fn vert_edges(&self,vert_id:MinkowskiVert)->impl AsRef<[MinkowskiDirectedEdge]>{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				let mut edges=Vec::new();
+				//detect shared volume when the other mesh is mirrored along a test edge dir
+				let v0f_thing=self.mesh0.vert_faces(v0);
+				let v1f_thing=self.mesh1.vert_faces(v1);
+				let v0f=v0f_thing.as_ref();
+				let v1f=v1f_thing.as_ref();
+				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				// scratch vector
+				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
+				face_normals.clone_from(&v0f_n);
+				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
+					let n=self.mesh0.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// TODO: there's gotta be a better way to do this
+					// drop faces beyond v0f_n
+					face_normals.truncate(v0f.len());
+					// make a set of faces from mesh0's perspective
+					for face_n in &v1f_n{
+						//add reflected mesh1 faces
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
+					}
+					if is_empty_volume(&face_normals){
+						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
+					}
+				}
+				face_normals.clone_from(&v1f_n);
+				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
+					let n=self.mesh1.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// drop faces beyond v1f_n
+					face_normals.truncate(v1f.len());
+					// make a set of faces from mesh1's perspective
+					for face_n in &v0f_n{
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
+					}
+					if is_empty_volume(&face_normals){
+						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
+					}
+				}
+				edges
+			},
+		}
+	}
+	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
+		unimplemented!();
+		#[expect(unreachable_code)]
+		Vec::new()
+	}
+}
+
+fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
+	let len=normals.len();
+	for i in 0..len-1{
+		for j in i+1..len{
+			let n=normals[i].cross(normals[j]);
+			let mut d_comp=None;
+			for k in 0..len{
+				if k!=i&&k!=j{
+					let d=n.dot(normals[k]).is_negative();
+					if let &Some(comp)=&d_comp{
+						// This is testing if d_comp*d < 0
+						if comp^d{
+							return true;
+						}
+					}else{
+						d_comp=Some(d);
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+#[test]
+fn test_is_empty_volume(){
+	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
+	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
+}

engine/physics/src/push_solve.rs

@@ -15,7 +15,6 @@ type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
 const RATIO_ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
 
 /// Information about a contact restriction
-#[derive(Debug,PartialEq)]
 pub struct Contact{
 	pub position:Planar64Vec3,
 	pub velocity:Planar64Vec3,
@@ -282,16 +281,16 @@ fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ra
 		.min_by_key(|&(t,_)|t)
 }
 
-pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->(Planar64Vec3,Conts<'_>){
+pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
 	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
 	loop{
 		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){
 			Some((t,cont))=>(t,cont),
-			None=>return (ray.origin,conts),
+			None=>return ray.origin,
 		};
 
 		if RATIO_ZERO.le_ratio(next_t){
-			return (ray.origin,conts);
+			return ray.origin;
 		}
 
 		//push_front
@@ -307,7 +306,7 @@ pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->(Planar64Vec3,Conts<'
 		let meet_point=ray.extrapolate(next_t);
 		match get_best_push_ray_and_conts(meet_point,conts.as_slice()){
 			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
-			None=>return (meet_point,conts),
+			None=>return meet_point,
 		}
 	}
 }
@@ -324,8 +323,9 @@ mod tests{
 				normal:vec3::Y,
 			}
 		];
-		let (point,conts)=push_solve(&contacts,vec3::NEG_Y);
-		assert_eq!(point,vec3::zero());
-		assert_eq!(conts.as_slice(),[&contacts[0]].as_slice());
+		assert_eq!(
+			vec3::zero(),
+			push_solve(&contacts,vec3::NEG_Y)
+		);
 	}
 }

engine/session/Cargo.toml

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam.workspace = true
+glam = "0.30.0"
 replace_with = "0.1.7"
-strafesnet_common.workspace = true
-strafesnet_physics.workspace = true
-strafesnet_settings.workspace = true
-strafesnet_snf.workspace = true
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+strafesnet_physics = { path = "../physics", registry = "strafesnet" }
+strafesnet_settings = { path = "../settings", registry = "strafesnet" }
+strafesnet_snf = { path = "../../lib/snf", registry = "strafesnet" }
 
 [lints]
 workspace = true

engine/session/src/session.rs

@@ -52,23 +52,16 @@ pub enum SessionControlInstruction{
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
+	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
 
 pub struct FrameState{
-	pub trajectory:physics::Trajectory,
+	pub body:physics::Body,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
 }
-impl FrameState{
-	pub fn pos(&self)->glam::Vec3{
-		self.trajectory.extrapolated_position(self.time).map(Into::<f32>::into).to_array().into()
-	}
-	pub fn angles(&self)->glam::Vec2{
-		self.camera.simulate_move_angles(glam::IVec2::ZERO)
-	}
-}
 
 pub struct Simulation{
 	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
@@ -84,9 +77,9 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime,data:&PhysicsData)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
 		FrameState{
-			trajectory:self.physics.camera_trajectory(data),
+			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
 		}
@@ -195,9 +188,9 @@ impl Session{
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time,&self.geometry_shared)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time,&self.geometry_shared)
+				replay.simulation.get_frame_state(time)
 			),
 		}
 	}
@@ -246,16 +239,12 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Restart(mode_id)));
-				// TODO: think about this harder.  This works around a bug where you fall infinitely when you reset.
-				self.simulation.timer.set_time(ins.time,PhysicsTime::ZERO);
 			},
 			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(mode_id,spawn_id)))=>{
 				self.clear_recording();
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Spawn(mode_id,spawn_id)));
-				// TODO: think about this harder.  This works around a bug where you fall infinitely when you reset.
-				self.simulation.timer.set_time(ins.time,PhysicsTime::ZERO);
 			},
 			Instruction::Input(SessionInputInstruction::Misc(misc_instruction))=>{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(misc_instruction));
@@ -264,14 +253,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// don't flush the buffered instructions in the mouse interpolator
 				// until the mouse is confirmed to be not moving at a later time
 				// what if they pause for 5ms lmao
-				match &self.view_state{
-					ViewState::Play=>{
-						_=self.simulation.timer.set_paused(ins.time,paused);
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,paused);
-					},
-				}
+				_=self.simulation.timer.set_paused(ins.time,paused);
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -392,6 +374,14 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 					},
 				}
 			},
+			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
+					},
+				}
+			}
 			Instruction::ChangeMap(complete_map)=>{
 				self.clear_recording();
 				self.change_map(complete_map);

engine/settings/Cargo.toml

@@ -6,8 +6,8 @@ edition = "2024"
 [dependencies]
 configparser = "3.0.2"
 directories = "6.0.0"
-glam.workspace = true
-strafesnet_common.workspace = true
+glam = "0.30.0"
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 
 [lints]
 workspace = true

integration-testing/Cargo.toml

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam.workspace = true
-strafesnet_common.workspace = true
-strafesnet_physics.workspace = true
-strafesnet_snf.workspace = true
+glam = "0.30.0"
+strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
+strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
+strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }
 # this is just for the primitive constructor
-strafesnet_rbx_loader.workspace = true
+strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }
 
 [lints]
 workspace = true

integration-testing/src/main.rs

@@ -71,16 +71,16 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 	for (i,ins) in bot.instructions.into_iter().enumerate(){
 		let state_deterministic=physics_deterministic.clone();
 		let state_filtered=physics_filtered.clone();
-		PhysicsContext::run_input_instruction(&mut physics_deterministic,physics_data,ins.clone());
+		PhysicsContext::run_input_instruction(&mut physics_deterministic,&physics_data,ins.clone());
 		match ins{
 			strafesnet_common::instruction::TimedInstruction{instruction:strafesnet_common::physics::Instruction::Idle,..}=>(),
 			other=>{
 				non_idle_count+=1;
 				// run
-				PhysicsContext::run_input_instruction(&mut physics_filtered,physics_data,other.clone());
+				PhysicsContext::run_input_instruction(&mut physics_filtered,&physics_data,other.clone());
 				// check if position matches
-				let b0=physics_deterministic.camera_trajectory(physics_data);
-				let b1=physics_filtered.camera_trajectory(physics_data);
+				let b0=physics_deterministic.camera_body();
+				let b1=physics_filtered.camera_body();
 				if b0.position!=b1.position{
 					let nanoseconds=start.elapsed().as_nanos() as u64;
 					println!("desync at instruction #{}",i);

integration-testing/src/test_scenes.rs

@@ -73,6 +73,7 @@ fn simultaneous_collision(){
 	let body=strafesnet_physics::physics::Body::new(
 		(vec3::int(5+2,0,0)>>1)+vec3::int(1,1,0),
 		vec3::int(-1,-1,0),
+		vec3::int(0,0,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -87,6 +88,7 @@ fn simultaneous_collision(){
 	let body=physics.body();
 	assert_eq!(body.position,vec3::int(5,0,0));
 	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(1));
 }
 #[test]
@@ -95,6 +97,7 @@ fn bug_3(){
 	let body=strafesnet_physics::physics::Body::new(
 		(vec3::int(5+2,0,0)>>1)+vec3::int(1,2,0),
 		vec3::int(-1,-1,0),
+		vec3::int(0,0,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -109,5 +112,6 @@ fn bug_3(){
 	let body=physics.body();
 	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
 	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }

integration-testing/src/tests.rs

@@ -22,6 +22,7 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	let body=strafesnet_physics::physics::Body::new(
 		vec3::raw_xyz(555690659654,1490485868773,1277783839382),
 		vec3::int(0,0,0),
+		vec3::int(0,-100,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
@@ -59,12 +60,9 @@ fn physics_bug_3()->Result<(),ReplayError>{
 		// vec3::raw_xyz(0,-96915585363,1265),
 		// vec3::raw_xyz(0,-429496729600,0),
 		// corner setup before wall hits
-		// vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
-		// vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
-		// vec3::raw_xyz(0,-429496729600,0),
-		// Actual bug 3 repro
-		vec3::raw_xyz(-2505538624455,3357963283914,557275711118),
-		vec3::raw_xyz(204188283920,-282280474198,166172785440),
+		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
+		vec3::raw_xyz(0,-429496729600,0),
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);

lib/bsp_loader/Cargo.toml

@@ -10,9 +10,9 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-glam.workspace = true
-strafesnet_common.workspace = true
-strafesnet_deferred_loader.workspace = true
+glam = "0.30.0"
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
 vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"

lib/common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_common"
-version = "0.8.5"
+version = "0.7.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -12,10 +12,10 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 arrayvec = "0.7.4"
 bitflags = "2.6.0"
-fixed_wide = { workspace = true, features = ["deferred-division","zeroes","wide-mul"] }
-linear_ops = { workspace = true, features = ["deferred-division","named-fields"] }
-ratio_ops = { workspace = true }
-glam.workspace = true
+fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
+linear_ops = { version = "0.1.1", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
+ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
+glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 
 [lints]

lib/common/src/integer.rs

@@ -56,14 +56,6 @@ impl<T> Time<T>{
 	pub const fn coerce<U>(self)->Time<U>{
 		Time::raw(self.0)
 	}
-	#[inline]
-	pub const fn div_euclid(self,other:Self)->Self{
-		Time::raw(self.0.div_euclid(other.0))
-	}
-	#[inline]
-	pub const fn rem_euclid(self,other:Self)->Self{
-		Time::raw(self.0.rem_euclid(other.0))
-	}
 }
 impl<T> From<Planar64> for Time<T>{
 	#[inline]
@@ -157,23 +149,10 @@ impl_time_i64_rhs_operator!(Shr,shr);
 impl_time_i64_rhs_operator!(Shl,shl);
 impl<T> core::ops::Mul<Time<T>> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
-	#[inline]
 	fn mul(self,rhs:Time<T>)->Self::Output{
 		Ratio::new(self*Fixed::raw(rhs.0),Planar64::raw(1_000_000_000))
 	}
 }
-impl<T> From<Time<T>> for f32{
-	#[inline]
-	fn from(value:Time<T>)->Self{
-		value.get() as f32/Time::<T>::ONE_SECOND.get() as f32
-	}
-}
-impl<T> From<Time<T>> for f64{
-	#[inline]
-	fn from(value:Time<T>)->Self{
-		value.get() as f64/Time::<T>::ONE_SECOND.get() as f64
-	}
-}
 #[cfg(test)]
 mod test_time{
 	use super::*;
@@ -235,11 +214,11 @@ impl Ratio64{
 	}
 	#[inline]
 	pub const fn mul_int(&self,rhs:i64)->i64{
-		(rhs as i128*self.num as i128/self.den as i128) as i64
+		rhs*self.num/(self.den as i64)
 	}
 	#[inline]
 	pub const fn rhs_div_int(&self,rhs:i64)->i64{
-		(rhs as i128*self.den as i128/self.num as i128) as i64
+		rhs*(self.den as i64)/self.num
 	}
 	#[inline]
 	pub const fn mul_ref(&self,rhs:&Ratio64)->Ratio64{
@@ -284,6 +263,7 @@ fn integer_decode_f64(f: f64) -> (u64, i16, i8) {
 pub enum Ratio64TryFromFloatError{
 	Nan,
 	Infinite,
+	Subnormal,
 	HighlyNegativeExponent(i16),
 	HighlyPositiveExponent(i16),
 }
@@ -318,10 +298,8 @@ fn ratio64_from_mes((m,e,s):(u64,i16,i8))->Result<Ratio64,Ratio64TryFromFloatErr
 
 		Ok(Ratio64::new(num as i64,den as u64).unwrap())
 	}else if e<0{
-		// simple exact representation
 		Ok(Ratio64::new((m as i64)*(s as i64),1<<-e).unwrap())
 	}else if (64-m.leading_zeros() as i16)+e<64{
-		// integer
 		Ok(Ratio64::new((m as i64)*(s as i64)*(1<<e),1).unwrap())
 	}else{
 		Err(Ratio64TryFromFloatError::HighlyPositiveExponent(e))
@@ -353,29 +331,6 @@ impl TryFrom<f64> for Ratio64{
 		}
 	}
 }
-#[cfg(test)]
-fn req(r0:Ratio64,r1:Ratio64){
-	println!("r0={r0:?} r1={r1:?}");
-	assert_eq!(r0.num(),r1.num(),"Nums not eq");
-	assert_eq!(r0.den(),r1.den(),"Dens not eq");
-}
-#[test]
-fn test_ratio64_from_float(){
-	req(2.0.try_into().unwrap(),Ratio64::new(2,1).unwrap());
-	req(1.0.try_into().unwrap(),Ratio64::new(1,1).unwrap());
-	req(0.5.try_into().unwrap(),Ratio64::new(1,2).unwrap());
-	req(1.1.try_into().unwrap(),Ratio64::new(2476979795053773,2251799813685248).unwrap());
-	req(0.8.try_into().unwrap(),Ratio64::new(3602879701896397,4503599627370496).unwrap());
-	req(0.61.try_into().unwrap(),Ratio64::new(5494391545392005,9007199254740992).unwrap());
-	req(0.01.try_into().unwrap(),Ratio64::new(5764607523034235,576460752303423488).unwrap());
-	req(0.001.try_into().unwrap(),Ratio64::new(1152921504606847,1152921504606846976).unwrap());
-	req(0.00001.try_into().unwrap(),Ratio64::new(89605456633725,8960545663372499267).unwrap());
-	req(0.00000000001.try_into().unwrap(),Ratio64::new(35204848,3520484800000000213).unwrap());
-	req(0.000000000000000001.try_into().unwrap(),Ratio64::new(11,10999999999999999213).unwrap());
-	req(2222222222222.0.try_into().unwrap(),Ratio64::new(2222222222222,1).unwrap());
-	req(core::f64::consts::PI.try_into().unwrap(),Ratio64::new(884279719003555,281474976710656).unwrap());
-}
-
 impl std::ops::Mul<Ratio64> for Ratio64{
 	type Output=Ratio64;
 	#[inline]

lib/common/src/model.rs

@@ -144,38 +144,10 @@ impl MeshBuilder{
 	}
 	pub fn build(
 		self,
-		mut polygon_groups:Vec<PolygonGroup>,
-		mut graphics_groups:Vec<IndexedGraphicsGroup>,
-		mut physics_groups:Vec<IndexedPhysicsGroup>,
+		polygon_groups:Vec<PolygonGroup>,
+		graphics_groups:Vec<IndexedGraphicsGroup>,
+		physics_groups:Vec<IndexedPhysicsGroup>,
 	)->Mesh{
-		let mut id=0;
-		let mut map=Vec::new();
-		polygon_groups.retain(|group|{
-			let keep=match group{
-				PolygonGroup::PolygonList(polygon_list)=>!polygon_list.0.is_empty(),
-			};
-			if keep{
-				map.push(Some(PolygonGroupId::new(id)));
-				id+=1;
-			}else{
-				map.push(None);
-			}
-			!keep
-		});
-		for group in &mut graphics_groups{
-			// drop empty groups
-			group.groups.retain(|polygon_group_id|map[polygon_group_id.get() as usize].is_some());
-			for polygon_group_id in &mut group.groups{
-				*polygon_group_id=map[polygon_group_id.get() as usize].unwrap();
-			}
-		}
-		for group in &mut physics_groups{
-			// drop empty groups
-			group.groups.retain(|polygon_group_id|map[polygon_group_id.get() as usize].is_some());
-			for polygon_group_id in &mut group.groups{
-				*polygon_group_id=map[polygon_group_id.get() as usize].unwrap();
-			}
-		}
 		let MeshBuilder{
 			unique_pos,
 			unique_normal,

lib/common/src/physics.rs

@@ -36,7 +36,6 @@ pub enum SetControlInstruction{
 	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
-	SetSprint(bool),
 }
 #[derive(Clone,Debug)]
 pub enum ModeInstruction{

lib/common/src/run.rs

@@ -53,23 +53,36 @@ impl std::fmt::Display for Error{
 impl std::error::Error for Error{}
 
 #[derive(Clone,Copy,Debug)]
-pub enum RunState{
+enum RunState{
 	Created,
 	Started{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Unpaused>},
 	Finished{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Paused>},
 }
-impl RunState{
+
+#[derive(Clone,Copy,Debug)]
+pub struct Run{
+	state:RunState,
+	flagged:Option<FlagReason>,
+}
+
+impl Run{
+	pub fn new()->Self{
+		Self{
+			state:RunState::Created,
+			flagged:None,
+		}
+	}
 	pub fn time(&self,time:PhysicsTime)->Time{
-		match &self{
+		match &self.state{
 			RunState::Created=>Time::ZERO,
 			RunState::Started{timer}=>timer.time(time),
 			RunState::Finished{timer}=>timer.time(),
 		}
 	}
 	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
-		match &self{
+		match &self.state{
 			RunState::Created=>{
-				*self=RunState::Started{
+				self.state=RunState::Started{
 					timer:TimerFixed::new(time,Time::ZERO),
 				};
 				Ok(())
@@ -80,10 +93,10 @@ impl RunState{
 	}
 	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
 		//this uses Copy
-		match &self{
+		match &self.state{
 			RunState::Created=>Err(Error::NotStarted),
 			RunState::Started{timer}=>{
-				*self=RunState::Finished{
+				self.state=RunState::Finished{
 					timer:timer.into_paused(time),
 				};
 				Ok(())
@@ -91,39 +104,12 @@ impl RunState{
 			RunState::Finished{..}=>Err(Error::AlreadyFinished),
 		}
 	}
-}
-
-#[derive(Clone,Copy,Debug)]
-pub struct Run{
-	state:RunState,
-	flag_reason:Option<FlagReason>,
-}
-
-impl Run{
-	pub fn new()->Self{
-		Self{
-			state:RunState::Created,
-			flag_reason:None,
-		}
-	}
-	pub fn time(&self,time:PhysicsTime)->Time{
-		self.state.time(time)
-	}
-	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
-		self.state.start(time)
-	}
-	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
-		self.state.finish(time)
-	}
 	pub fn flag(&mut self,flag_reason:FlagReason){
 		//don't replace the first reason the run was flagged
-		if self.flag_reason.is_none(){
-			self.flag_reason=Some(flag_reason);
+		if self.flagged.is_none(){
+			self.flagged=Some(flag_reason);
 		}
 	}
-	pub fn flag_reason(&self)->Option<FlagReason>{
-		self.flag_reason
-	}
 	pub fn get_finish_time(&self)->Option<Time>{
 		match &self.state{
 			RunState::Finished{timer}=>Some(timer.time()),

lib/common/src/timer.rs

@@ -69,8 +69,10 @@ impl<In,Out> Scaled<In,Out>
 	const fn get_scale(&self)->Ratio64{
 		self.scale
 	}
-	const fn set_scale(&mut self,new_scale:Ratio64){
+	fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
+		let new_time=self.get_time(time);
 		self.scale=new_scale;
+		self.set_time(time,new_time);
 	}
 }
 
@@ -130,7 +132,7 @@ pub struct TimerFixed<T:TimerState,P:PauseState>{
 	_paused:P,
 }
 
-//some scaled timer methods are generic across PauseState
+//scaled timer methods are generic across PauseState
 impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
 	where Time<In>:Copy,
 {
@@ -145,22 +147,8 @@ impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
 	pub const fn get_scale(&self)->Ratio64{
 		self.state.get_scale()
 	}
-}
-// setting the scale of an unpaused timer is different than a paused timer
-impl<In,Out> TimerFixed<Scaled<In,Out>,Unpaused>
-	where Time<In>:Copy,
-{
 	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
-		let new_time=self.state.get_time(time);
-		self.state.set_scale(new_scale);
-		self.state.set_time(time,new_time);
-	}
-}
-impl<In,Out> TimerFixed<Scaled<In,Out>,Paused>
-	where Time<In>:Copy,
-{
-	pub fn set_scale(&mut self,new_scale:Ratio64){
-		self.state.set_scale(new_scale);
+		self.state.set_scale(time,new_scale)
 	}
 }
 
@@ -317,7 +305,7 @@ impl<In,Out> Timer<Scaled<In,Out>>
 	}
 	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
 		match self{
-			Self::Paused(timer)=>timer.set_scale(new_scale),
+			Self::Paused(timer)=>timer.set_scale(time,new_scale),
 			Self::Unpaused(timer)=>timer.set_scale(time,new_scale),
 		}
 	}

lib/deferred_loader/Cargo.toml

@@ -10,7 +10,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-strafesnet_common.workspace = true
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 
 [lints]
 workspace = true

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.2.2"
+version = "0.2.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -17,7 +17,7 @@ zeroes=["dep:arrayvec"]
 bnum = "0.13.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
-ratio_ops = { workspace = true, optional = true }
+ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
 
 [lints]
 workspace = true

lib/fixed_wide/src/fixed.rs

@@ -7,7 +7,7 @@ const BNUM_DIGIT_WIDTH:usize=64;
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
 pub struct Fixed<const N:usize,const F:usize>{
-	bits:BInt<{N}>,
+	pub(crate)bits:BInt<{N}>,
 }
 
 impl<const N:usize,const F:usize> Fixed<N,F>{
@@ -366,7 +366,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 
 // This macro is not used in the default configuration.
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{

lib/linear_ops/Cargo.toml

@@ -14,12 +14,12 @@ fixed-wide=["dep:fixed_wide","dep:paste"]
 deferred-division=["dep:ratio_ops"]
 
 [dependencies]
-ratio_ops = { workspace = true, optional = true }
-fixed_wide = { workspace = true, optional = true }
+ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
+fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", optional = true }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]
-fixed_wide = { workspace = true, features = ["wide-mul"] }
+fixed_wide = { path = "../fixed_wide", registry = "strafesnet", features = ["wide-mul"] }
 
 [lints]
 workspace = true

lib/rbx_loader/Cargo.toml

@@ -11,18 +11,18 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 bytemuck = "1.14.3"
-glam.workspace = true
-regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
+glam = "0.30.0"
+regex = { version = "1.11.3", default-features = false }
+rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
 rbx_mesh = "0.5.0"
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
-strafesnet_common.workspace = true
-strafesnet_deferred_loader.workspace = true
-rbx_binary = "2.0.1"
-rbx_dom_weak = "4.1.0"
-rbx_reflection = "6.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_xml = "2.0.1"
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
 
 [lints]
 workspace = true

lib/rbx_loader/src/rbx.rs

@@ -559,7 +559,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|
@@ -867,11 +867,6 @@ impl PartialMap1<'_>{
 				deferred_model_deferred_attributes.model.mesh,
 				deferred_model_deferred_attributes.render
 			)?;
-			// If the mesh size is zero we can't auto-scale it, throw it out.
-			if mesh_size.x==integer::Fixed::ZERO||mesh_size.y==integer::Fixed::ZERO||mesh_size.z==integer::Fixed::ZERO{
-				print!("[rbx_loader] Mesh with zero size!");
-				return None;
-			}
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_model_deferred_attributes.model.deferred_attributes,

lib/rbx_loader/src/union.rs

@@ -104,7 +104,7 @@ fn build_mesh2(
 		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
 			polygon_groups_normal_id[normal_id as usize-1].push(face);
 		}else{
-			print!("[union] Empty face!");
+			panic!("Empty face!");
 		}
 	}
 	Ok(())
@@ -158,7 +158,7 @@ fn build_mesh5(
 		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
 			polygon_groups_normal_id[normal_id as usize-1].push(face);
 		}else{
-			print!("[union] Empty face!");
+			panic!("Empty face!");
 		}
 	}
 	Ok(())

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.2"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -12,13 +12,13 @@ default=["run-service"]
 run-service=[]
 
 [dependencies]
-glam.workspace = true
+glam = "0.30.0"
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
-rbx_dom_weak = "4.1.0"
-rbx_reflection = "6.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_types = "3.1.0"
+rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_types = "2.0.0"
 
 [lints]
 workspace = true

lib/roblox_emulator/src/context.rs

@@ -52,7 +52,7 @@ impl Context{
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get().unwrap();
+		let db=rbx_reflection_database::get();
 		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};

lib/roblox_emulator/src/runner/enum.rs

@@ -37,7 +37,7 @@ impl PartialEq for EnumItem<'_>{
 pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get().unwrap();
+		let db=rbx_reflection_database::get();
 		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }

lib/roblox_emulator/src/runner/instance/instance.rs

@@ -37,7 +37,7 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>
 }
 
 pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
@@ -80,14 +80,14 @@ pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak
 }
 
 pub fn find_first_child_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
 pub fn find_first_descendant_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
@@ -282,7 +282,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
-				let db=rbx_reflection_database::get().unwrap();
+				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
@@ -344,7 +344,7 @@ impl mlua::UserData for Instance{
 			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
-				let db=rbx_reflection_database::get().unwrap();
+				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)

lib/snf/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_snf"
-version = "0.3.2"
+version = "0.3.1"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -8,7 +8,7 @@ edition = "2024"
 [dependencies]
 binrw = "0.15.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common.workspace = true
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 
 [lints]
 workspace = true

lib/snf/src/newtypes/physics.rs

@@ -88,11 +88,6 @@ pub enum Instruction{
 	PracticeFly,
 	#[brw(magic=14u8)]
 	SetSensitivity(super::integer::Ratio64Vec2),
-	#[brw(magic=15u8)]
-	SetSprint(
-		#[br(map=bool_from_u8)]
-		#[bw(map=bool_into_u8)]
-		bool),
 	#[brw(magic=255u8)]
 	Idle,
 }
@@ -121,7 +116,6 @@ impl TryInto<strafesnet_common::physics::Instruction> for Instruction{
 			Instruction::SetMoveForward(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state.into())),
 			Instruction::SetJump(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state.into())),
 			Instruction::SetZoom(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state.into())),
-			Instruction::SetSprint(state)=>strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetSprint(state.into())),
 			Instruction::Reset=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset),
 			Instruction::Restart(mode_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(strafesnet_common::gameplay_modes::ModeId::new(mode_id))),
 			Instruction::Spawn(mode_id,stage_id)=>strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(
@@ -148,7 +142,6 @@ impl TryFrom<strafesnet_common::physics::Instruction> for Instruction{
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetMoveForward(state))=>Ok(Instruction::SetMoveForward(state.into())),
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetJump(state))=>Ok(Instruction::SetJump(state.into())),
 			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetZoom(state))=>Ok(Instruction::SetZoom(state.into())),
-			strafesnet_common::physics::Instruction::SetControl(strafesnet_common::physics::SetControlInstruction::SetSprint(state))=>Ok(Instruction::SetSprint(state.into())),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Reset)=>Ok(Instruction::Reset),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Restart(mode_id))=>Ok(Instruction::Restart(mode_id.get())),
 			strafesnet_common::physics::Instruction::Mode(strafesnet_common::physics::ModeInstruction::Spawn(mode_id,stage_id))=>Ok(Instruction::Spawn(

map-tool/Cargo.toml

@@ -13,15 +13,15 @@ futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
-rbx_binary = "2.0.1"
-rbx_dom_weak = "4.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_xml = "2.0.1"
+rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_bsp_loader.workspace = true
-strafesnet_deferred_loader.workspace = true
-strafesnet_rbx_loader.workspace = true
-strafesnet_snf.workspace = true
+strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
+strafesnet_rbx_loader = { version = "0.7.0", path = "../lib/rbx_loader", registry = "strafesnet" }
+strafesnet_snf = { version = "0.3.1", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
 vbsp = "0.9.1"

strafe-client/Cargo.toml

@@ -16,19 +16,19 @@ source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
-glam.workspace = true
+glam = "0.30.0"
 parking_lot = "0.12.1"
 pollster = "0.4.0"
-strafesnet_bsp_loader = { workspace = true, optional = true }
-strafesnet_common.workspace = true
-strafesnet_deferred_loader = { workspace = true, optional = true }
-strafesnet_graphics.workspace = true
-strafesnet_physics.workspace = true
-strafesnet_rbx_loader = { workspace = true, optional = true }
-strafesnet_session.workspace = true
-strafesnet_settings.workspace = true
-strafesnet_snf = { workspace = true, optional = true }
-wgpu = "28.0.0"
+strafesnet_bsp_loader = { path = "../lib/bsp_loader", registry = "strafesnet", optional = true }
+strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
+strafesnet_deferred_loader = { path = "../lib/deferred_loader", registry = "strafesnet", optional = true }
+strafesnet_graphics = { path = "../engine/graphics", registry = "strafesnet" }
+strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
+strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", optional = true }
+strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
+strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
+strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
+wgpu = "27.0.0"
 winit = "0.30.7"
 
 [profile.dev]

strafe-client/models/teslacyberv3.0.mtl

@@ -0,0 +1,62 @@
+# Blender MTL File: 'teslacyberv3.0.blend'
+# Material Count: 6
+
+newmtl Material
+Ns 65.476285
+Ka 1.000000 1.000000 1.000000
+Kd 0.411568 0.411568 0.411568
+Ks 0.614679 0.614679 0.614679
+Ke 0.000000 0.000000 0.000000
+Ni 36.750000
+d 1.000000
+illum 3
+
+newmtl Материал
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2
+
+newmtl Материал.001
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.026240 0.026240 0.026240
+Ks 0.000000 0.000000 0.000000
+Ke 0.000000 0.000000 0.000000
+Ni 1.450000
+d 1.000000
+illum 1
+
+newmtl Материал.002
+Ns 0.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.031837 0.032429 0.029425
+Ks 0.169725 0.169725 0.169725
+Ke 0.000000 0.000000 0.000000
+Ni 0.000000
+d 1.000000
+illum 2
+
+newmtl Материал.003
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.023585 0.083235 0.095923
+Ks 1.000000 1.000000 1.000000
+Ke 0.000000 0.000000 0.000000
+Ni 45.049999
+d 1.000000
+illum 3
+
+newmtl Материал.004
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2

strafe-client/src/graphics_worker.rs

@@ -37,8 +37,7 @@ pub fn new(
 				config.width=size.width.max(1);
 				config.height=size.height.max(1);
 				surface.configure(&device,&config);
-				let fov=user_settings.calculate_fov(1.0,&glam::uvec2(config.width,config.height)).as_vec2();
-				graphics.resize(&device,&config,fov);
+				graphics.resize(&device,&config,&user_settings);
 				println!("Resize took {:?}",t0.elapsed());
 			}
 			Instruction::Render(frame_state)=>{
@@ -57,7 +56,7 @@ pub fn new(
 					..wgpu::TextureViewDescriptor::default()
 				});
 
-				graphics.render(&view,&device,&queue,graphics::view_inv(frame_state.pos(),frame_state.angles()));
+				graphics.render(&view,&device,&queue,frame_state);
 
 				frame.present();
 			}

strafe-client/src/main.rs

@@ -9,5 +9,5 @@ mod graphics_worker;
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 
 fn main(){
-	pollster::block_on(setup::setup_and_start(TITLE));
+	setup::setup_and_start(TITLE);
 }

strafe-client/src/setup.rs

@@ -1,38 +1,199 @@
-use strafesnet_graphics::setup;
+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()
+	}
+}
 
+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 attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
 	event_loop.create_window(attr)
 }
+fn create_instance()->SetupContextPartial1{
+	let backends=wgpu::Backends::from_env().unwrap_or_default();
+	SetupContextPartial1{
+		backends,
+		instance:Default::default(),
+	}
+}
+impl SetupContextPartial1{
+	fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
+		Ok(SetupContextPartial2{
+			backends:self.backends,
+			surface:self.instance.create_surface(window)?,
+			instance:self.instance,
+		})
+	}
+}
+struct SetupContextPartial2<'a>{
+	backends:wgpu::Backends,
+	instance:wgpu::Instance,
+	surface:wgpu::Surface<'a>,
+}
+impl<'a> SetupContextPartial2<'a>{
+	fn pick_adapter(self)->SetupContextPartial3<'a>{
+		let adapter;
 
-pub async fn setup_and_start(title:&str){
+		//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{
+			surface:self.surface,
+			adapter,
+		}
+	}
+}
+struct SetupContextPartial3<'a>{
+	surface:wgpu::Surface<'a>,
+	adapter:wgpu::Adapter,
+}
+impl<'a> SetupContextPartial3<'a>{
+	fn request_device(self)->SetupContextPartial4<'a>{
+		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=strafesnet_graphics::graphics::required_limits().using_resolution(self.adapter.limits());
+
+		let (device, queue)=pollster::block_on(self.adapter
+			.request_device(
+				&wgpu::DeviceDescriptor{
+					label:None,
+					required_features:(optional_features&self.adapter.features())|required_features,
+					required_limits:needed_limits,
+					memory_hints:wgpu::MemoryHints::Performance,
+					trace:wgpu::Trace::Off,
+					experimental_features:wgpu::ExperimentalFeatures::disabled(),
+				},
+			))
+			.expect("Unable to find a suitable GPU adapter!");
+
+		SetupContextPartial4{
+			surface:self.surface,
+			adapter:self.adapter,
+			device,
+			queue,
+		}
+	}
+}
+struct SetupContextPartial4<'a>{
+	surface:wgpu::Surface<'a>,
+	adapter:wgpu::Adapter,
+	device:wgpu::Device,
+	queue:wgpu::Queue,
+}
+impl<'a> SetupContextPartial4<'a>{
+	fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
+		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{
+			surface:self.surface,
+			device:self.device,
+			queue:self.queue,
+			config,
+		}
+	}
+}
+pub struct SetupContext<'a>{
+	pub surface:wgpu::Surface<'a>,
+	pub device:wgpu::Device,
+	pub queue:wgpu::Queue,
+	pub config:wgpu::SurfaceConfiguration,
+}
+
+pub fn setup_and_start(title:&str){
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
-	let window=create_window(title,&event_loop).unwrap();
-
 	println!("Initializing the surface...");
 
-	let instance=setup::step1::create_instance();
+	let partial_1=create_instance();
 
-	let surface=setup::step2::create_surface(&instance,&window).unwrap();
+	let window=create_window(title,&event_loop).unwrap();
 
-	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
+	let partial_2=partial_1.create_surface(&window).unwrap();
 
-	let (device,queue)=setup::step4::request_device(&adapter).await;
+	let partial_3=partial_2.pick_adapter();
+
+	let partial_4=partial_3.request_device();
 
 	let size=window.inner_size();
-	let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height));
+
+	let setup_context=partial_4.configure_surface(&size);
 
 	//dedicated thread to ping request redraw back and resize the window doesn't seem logical
 
 	//the thread that spawns the physics thread
 	let mut window_thread=crate::window::worker(
 		&window,
-		device,
-		queue,
-		surface,
-		config,
+		setup_context,
 	);
 
 	for arg in std::env::args().skip(1){

strafe-client/src/window.rs

@@ -15,7 +15,6 @@ pub enum Instruction{
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
 	mouse_pos:glam::DVec2,
-	simulation_paused:bool,
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTime>>,
@@ -25,35 +24,6 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<u32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x/2,self.screen_size.y/2)
 	}
-	fn free_mouse(&mut self){
-		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),
-		}
-		self.window.set_cursor_visible(true);
-	}
-	fn lock_mouse(&mut self){
-		//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(false);
-	}
 	fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
 		match event{
 			winit::event::WindowEvent::DroppedFile(path)=>{
@@ -64,10 +34,6 @@ impl WindowContext<'_>{
 				}
 			},
 			winit::event::WindowEvent::Focused(state)=>{
-				// don't unpause if manually paused
-				if self.simulation_paused{
-					return;
-				}
 				//pause unpause
 				self.physics_thread.send(TimedInstruction{
 					time,
@@ -80,8 +46,35 @@ impl WindowContext<'_>{
 				..
 			}=>{
 				match (logical_key,state){
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>self.free_mouse(),
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>self.lock_mouse(),
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>{
+						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),
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>{
+						//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(state.is_pressed());
+					},
 					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
 						if self.window.fullscreen().is_some(){
 							self.window.set_fullscreen(None);
@@ -138,18 +131,8 @@ impl WindowContext<'_>{
 
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Shift)=>input_ctrl!(SetSprint,s),
 							// TODO: bind system so playback pausing can use spacebar
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>if s{
-								let paused=!self.simulation_paused;
-								self.simulation_paused=paused;
-								if paused{
-									self.free_mouse();
-								}else{
-									self.lock_mouse();
-								}
-								Some(SessionInstructionSubset::Control(SessionControlInstruction::SetPaused(paused)))
-							}else{None},
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>session_playback!(TogglePaused,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_playback!(IncreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_playback!(DecreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_playback!(SkipBack,s),
@@ -239,10 +222,7 @@ impl WindowContext<'_>{
 }
 pub fn worker<'a>(
 	window:&'a winit::window::Window,
-	device:wgpu::Device,
-	queue:wgpu::Queue,
-	surface:wgpu::Surface<'a>,
-	config:wgpu::SurfaceConfiguration,
+	setup_context:crate::setup::SetupContext<'a>,
 )->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>{
 	// WindowContextSetup::new
 	#[cfg(feature="user-install")]
@@ -252,17 +232,15 @@ pub fn worker<'a>(
 
 	let user_settings=directories.settings();
 
-	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&device,&queue,&config);
+	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
+	graphics.load_user_settings(&user_settings);
 
 	//WindowContextSetup::into_context
-	let screen_size=glam::uvec2(config.width,config.height);
-	let fov=user_settings.calculate_fov(1.0,&screen_size).as_vec2();
-	graphics.resize(&device,&config,fov);
-	let graphics_thread=crate::graphics_worker::new(graphics,config,surface,device,queue);
+	let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
+	let graphics_thread=crate::graphics_worker::new(graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
 		mouse_pos:glam::DVec2::ZERO,
-		simulation_paused:false,
 		//make sure to update this!!!!!
 		screen_size,
 		window,