fix lints

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

Cargo.lock

@@ -813,10 +813,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f"
 
-[[package]]
-name = "dag"
-version = "0.1.0"
-
 [[package]]
 name = "ddsfile"
 version = "0.5.2"

Cargo.toml

@@ -7,7 +7,6 @@ members = [
 	"integration-testing",
 	"lib/bsp_loader",
 	"lib/common",
-	"lib/dag",
 	"lib/deferred_loader",
 	"lib/fixed_wide",
 	"lib/linear_ops",

engine/graphics/src/graphics.rs

@@ -5,7 +5,7 @@ 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};
+use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex,DebugGraphicsVertex};
 
 pub fn required_limits()->wgpu::Limits{
 	wgpu::Limits::default()
@@ -36,12 +36,22 @@ struct GraphicsModel{
 	instance_count:u32,
 }
 
+struct DebugGraphicsMesh{
+	indices:Indices,
+	vertex_buf:wgpu::Buffer,
+}
+struct DebugGraphicsModel{
+	debug_mesh_id:u32,
+	bind_group:wgpu::BindGroup,
+}
+
 struct GraphicsSamplers{
 	repeat:wgpu::Sampler,
 }
 
 struct GraphicsBindGroupLayouts{
 	model:wgpu::BindGroupLayout,
+	debug_model:wgpu::BindGroupLayout,
 }
 
 struct GraphicsBindGroups{
@@ -52,6 +62,7 @@ struct GraphicsBindGroups{
 struct GraphicsPipelines{
 	skybox:wgpu::RenderPipeline,
 	model:wgpu::RenderPipeline,
+	debug:wgpu::RenderPipeline,
 }
 
 struct GraphicsCamera{
@@ -132,6 +143,8 @@ pub struct GraphicsState{
 	camera_buf:wgpu::Buffer,
 	temp_squid_texture_view:wgpu::TextureView,
 	models:Vec<GraphicsModel>,
+	debug_meshes:Vec<DebugGraphicsMesh>,
+	debug_models:Vec<DebugGraphicsModel>,
 	depth_view:wgpu::TextureView,
 	staging_belt:wgpu::util::StagingBelt,
 }
@@ -166,6 +179,76 @@ impl GraphicsState{
 		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 debug meshes, each debug model refers to one
+		self.debug_meshes=map.meshes.iter().map(|mesh|{
+			let vertices:Vec<DebugGraphicsVertex>=mesh.unique_vertices.iter().map(|vertex|{
+				DebugGraphicsVertex{
+					pos:mesh.unique_pos[vertex.pos.get() as usize].to_array().map(Into::into),
+					normal:mesh.unique_normal[vertex.normal.get() as usize].to_array().map(Into::into),
+				}
+			}).collect();
+			let vertex_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+				label:Some("Vertex"),
+				contents:bytemuck::cast_slice(&vertices),
+				usage:wgpu::BufferUsages::VERTEX,
+			});
+
+			let mut indices=Vec::new();
+			for physics_group in &mesh.physics_groups{
+				for polygon_group_id in &physics_group.groups{
+					for poly in mesh.polygon_groups[polygon_group_id.get() as usize].polys(){
+						// triangulate
+						let mut poly_vertices=poly.into_iter().copied();
+						if let (Some(a),Some(mut b))=(poly_vertices.next(),poly_vertices.next()){
+							for c in poly_vertices{
+								indices.extend([a,b,c]);
+								b=c;
+							}
+						}
+					}
+				}
+			}
+
+			DebugGraphicsMesh{
+				indices:if (u32::MAX as usize)<vertices.len(){
+					panic!("Model has too many vertices!")
+				}else if (u16::MAX as usize)<vertices.len(){
+					Indices::new(device,&indices.into_iter().map(|vertex_idx|vertex_idx.get() as u32).collect(),wgpu::IndexFormat::Uint32)
+				}else{
+					Indices::new(device,&indices.into_iter().map(|vertex_idx|vertex_idx.get() as u16).collect(),wgpu::IndexFormat::Uint16)
+				},
+				vertex_buf,
+			}
+		}).collect();
+
+		//generate debug models, only one will be rendered at a time
+		self.debug_models=map.models.iter().enumerate().map(|(model_id,model)|{
+			let model_uniforms=get_instances_buffer_data(&[GraphicsModelOwned{
+				transform:model.transform.into(),
+				normal_transform:glam::Mat3::from_cols_array_2d(&model.transform.matrix3.to_array().map(|row|row.map(Into::into))).inverse().transpose(),
+				color:GraphicsModelColor4::new(glam::vec4(1.0,0.0,0.0,0.2)),
+			}]);
+			let model_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+				label:Some(format!("Debug Model{} Buf",model_id).as_str()),
+				contents:bytemuck::cast_slice(&model_uniforms),
+				usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
+			});
+			let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
+				layout:&self.bind_group_layouts.debug_model,
+				entries:&[
+					wgpu::BindGroupEntry{
+						binding:0,
+						resource:model_buf.as_entire_binding(),
+					},
+				],
+				label:Some(format!("Debug Model{} Bind Group",model_id).as_str()),
+			});
+			DebugGraphicsModel{
+				debug_mesh_id:model.mesh.get(),
+				bind_group,
+			}
+		}).collect();
+
 		//generate texture view per texture
 		let texture_views:HashMap<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
@@ -608,6 +691,21 @@ impl GraphicsState{
 				},
 			],
 		});
+		let debug_model_bind_group_layout=device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor{
+			label:Some("Debug Model Bind Group Layout"),
+			entries:&[
+				wgpu::BindGroupLayoutEntry{
+					binding:0,
+					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT,
+					ty:wgpu::BindingType::Buffer{
+						ty:wgpu::BufferBindingType::Uniform,
+						has_dynamic_offset:false,
+						min_binding_size:None,
+					},
+					count:None,
+				},
+			],
+		});
 
 		let clamp_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
 			label:Some("Clamp Sampler"),
@@ -756,6 +854,14 @@ impl GraphicsState{
 			],
 			immediate_size:0,
 		});
+		let debug_model_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
+				label:None,
+				bind_group_layouts:&[
+					&camera_bind_group_layout,
+					&debug_model_bind_group_layout,
+				],
+				push_constant_ranges:&[],
+			});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
 			bind_group_layouts:&[
@@ -831,6 +937,45 @@ impl GraphicsState{
 			multiview_mask:None,
 			cache:None,
 		});
+		let debug_model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
+			label:Some("Debug Model Pipeline"),
+			layout:Some(&debug_model_pipeline_layout),
+			vertex:wgpu::VertexState{
+				module:&shader,
+				entry_point:Some("vs_debug"),
+				buffers:&[wgpu::VertexBufferLayout{
+					array_stride:size_of::<DebugGraphicsVertex>() as wgpu::BufferAddress,
+					step_mode:wgpu::VertexStepMode::Vertex,
+					attributes:&wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3],
+				}],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			},
+			fragment:Some(wgpu::FragmentState{
+				module:&shader,
+				entry_point:Some("fs_debug"),
+				targets:&[Some(wgpu::ColorTargetState{
+					format:config.view_formats[0],
+					blend:Some(wgpu::BlendState::ALPHA_BLENDING),
+					write_mask:wgpu::ColorWrites::default(),
+				})],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			}),
+			primitive:wgpu::PrimitiveState{
+				front_face:wgpu::FrontFace::Cw,
+				cull_mode:Some(wgpu::Face::Front),
+				..Default::default()
+			},
+			depth_stencil:Some(wgpu::DepthStencilState{
+				format:Self::DEPTH_FORMAT,
+				depth_write_enabled:true,
+				depth_compare:wgpu::CompareFunction::Always,
+				stencil:wgpu::StencilState::default(),
+				bias:wgpu::DepthBiasState::default(),
+			}),
+			multisample:wgpu::MultisampleState::default(),
+			multiview:None,
+			cache:None,
+		});
 
 		let camera=GraphicsCamera::default();
 		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
@@ -870,7 +1015,8 @@ impl GraphicsState{
 		Self{
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
-				model:model_pipeline
+				model:model_pipeline,
+				debug:debug_model_pipeline,
 			},
 			bind_groups:GraphicsBindGroups{
 				camera:camera_bind_group,
@@ -879,9 +1025,14 @@ impl GraphicsState{
 			camera,
 			camera_buf,
 			models:Vec::new(),
+			debug_meshes:Vec::new(),
+			debug_models:Vec::new(),
 			depth_view,
 			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
-			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
+			bind_group_layouts:GraphicsBindGroupLayouts{
+				model:model_bind_group_layout,
+				debug_model:debug_model_bind_group_layout,
+			},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
 		}
@@ -909,7 +1060,7 @@ impl GraphicsState{
 
 		// update rotation
 		let camera_uniforms=self.camera.to_uniform_data(
-			frame_state.trajectory.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
+			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
@@ -970,6 +1121,7 @@ impl GraphicsState{
 			rpass.set_bind_group(0,&self.bind_groups.camera,&[]);
 			rpass.set_bind_group(1,&self.bind_groups.skybox_texture,&[]);
 
+			// Draw all models.
 			rpass.set_pipeline(&self.pipelines.model);
 			for model in &self.models{
 				rpass.set_bind_group(2,&model.bind_group,&[]);
@@ -981,6 +1133,19 @@ impl GraphicsState{
 
 			rpass.set_pipeline(&self.pipelines.skybox);
 			rpass.draw(0..3,0..1);
+
+			// render a single debug_model in red
+			if let Some(model_id)=frame_state.debug_model{
+				if let Some(model)=self.debug_models.get(model_id.get() as usize){
+					let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
+					rpass.set_pipeline(&self.pipelines.debug);
+					rpass.set_bind_group(1,&model.bind_group,&[]);
+					rpass.set_vertex_buffer(0,mesh.vertex_buf.slice(..));
+					rpass.set_index_buffer(mesh.indices.buf.slice(..),mesh.indices.format);
+					//TODO: loop over triangle strips
+					rpass.draw_indexed(0..mesh.indices.count,0,0..1);
+				}
+			}
 		}
 
 		queue.submit(std::iter::once(encoder.finish()));

engine/graphics/src/model.rs

@@ -8,6 +8,12 @@ pub struct GraphicsVertex{
 	pub normal:[f32;3],
 	pub color:[f32;4],
 }
+#[derive(Clone,Copy,Pod,Zeroable)]
+#[repr(C)]
+pub struct DebugGraphicsVertex{
+	pub pos:[f32;3],
+	pub normal:[f32;3],
+}
 #[derive(Clone,Copy,id::Id)]
 pub struct IndexedGraphicsMeshOwnedRenderConfigId(u32);
 pub struct IndexedGraphicsMeshOwnedRenderConfig{

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,6 +1,6 @@
 use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
-use crate::physics::{Time,Trajectory};
+use crate::physics::{Time,Body};
 
 use core::ops::Bound;
 
@@ -74,7 +74,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		<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;
@@ -86,8 +86,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				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;
@@ -101,8 +101,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//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;
@@ -117,15 +117,15 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				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;
@@ -136,8 +136,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				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);
@@ -152,8 +152,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				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);
@@ -166,11 +166,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		}
 		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/minimum_difference.rs

@@ -367,8 +367,8 @@ fn reduce4<M:MeshQuery>(
 
 	// 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
@@ -396,6 +396,8 @@ fn reduce4<M:MeshQuery>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
+		}else{
+			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -408,6 +410,8 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}
 
@@ -424,15 +428,17 @@ fn reduce4<M:MeshQuery>(
 	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:narrow_dir2(uv),
+				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:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}
 	}
 
 	// local u_u = u:Dot(u)
@@ -464,15 +470,17 @@ fn reduce4<M:MeshQuery>(
 		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:narrow_dir2(uv),
+					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:narrow_dir2(-uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
 		}
 
 		// return direction, a0, a1, b0, b1
@@ -487,15 +495,17 @@ fn reduce4<M:MeshQuery>(
 	// 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:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex1([v0]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
 	}
 
 	// return direction, a0, a1
@@ -525,6 +535,24 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
+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
+	)
+}
+
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition<Vert>{
@@ -658,7 +686,7 @@ impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 		}
 	}
 }
-/// This function hops along parallel vertices until it finds the EV which contains the closest point to `point`.
+/// 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
@@ -676,7 +704,7 @@ fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Pla
 	finder.crawl_boundaries(vert_id,point)
 }
 
-/// This function hops along connected vertices until it finds the FEV which contains the closest point to `point`.
+/// 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<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiVert>,point:Planar64Vec3)->FEV::<MinkowskiMesh<'a>>{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
@@ -740,7 +768,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
@@ -748,7 +780,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
 				},
 			})
 		},
@@ -764,24 +800,6 @@ 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,

engine/physics/src/model.rs

@@ -5,7 +5,7 @@ use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
 
-type Trajectory=crate::body::Trajectory<strafesnet_common::physics::TimeInner>;
+type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -16,14 +16,14 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 
 pub trait UndirectedEdge{
 	type DirectedEdge:Copy+DirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge;
+	fn as_directed(&self,parity:bool)->Self::DirectedEdge;
 }
-pub trait DirectedEdge:Copy{
+pub trait DirectedEdge{
 	type UndirectedEdge:Copy+std::fmt::Debug+UndirectedEdge;
-	fn as_undirected(self)->Self::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{
+	fn reverse(&self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
 		self.as_undirected().as_directed(!self.parity())
 	}
 }
@@ -45,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{
@@ -91,6 +91,7 @@ pub trait MeshQuery{
 		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
 	}
 	/// This must return a point inside the mesh.
+	#[expect(dead_code)]
 	fn hint_point(&self)->Planar64Vec3;
 	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
@@ -526,6 +527,9 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
+	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
+		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
+	}
 }
 impl MeshQuery for TransformedMesh<'_>{
 	type Face=SubmeshFaceId;
@@ -597,7 +601,7 @@ impl core::ops::Neg for MinkowskiVert{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -605,14 +609,14 @@ pub enum MinkowskiEdge{
 }
 impl UndirectedEdge for MinkowskiEdge{
 	type DirectedEdge=MinkowskiDirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge{
+	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),
+			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)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiDirectedEdge{
 	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
 	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
@@ -620,10 +624,10 @@ pub enum MinkowskiDirectedEdge{
 }
 impl DirectedEdge for MinkowskiDirectedEdge{
 	type UndirectedEdge=MinkowskiEdge;
-	fn as_undirected(self)->Self::UndirectedEdge{
+	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),
+			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
+			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
 		}
 	}
 	fn parity(&self)->bool{
@@ -670,40 +674,35 @@ impl MinkowskiMesh<'_>{
 			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)?;
+	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,trajectory,range.start_bound(),range.end_bound()).hit()
+		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 	}
-	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_out(&self,relative_body:&Body,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 time=match upper_bound{
+			Bound::Included(&time)=>time,
+			Bound::Excluded(&time)=>time,
+			Bound::Unbounded=>unimplemented!("unbounded collision out"),
 		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?;
 		// 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;
+		let infinity_body=-relative_body;
 		//continue backwards along the body parabola
-		fev.crawl(self,&time_reversed_trajectory,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+		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,trajectory:&Trajectory,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+	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-trajectory.time).to_ratio());
-		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.time));
+		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(){
@@ -715,8 +714,8 @@ impl MinkowskiMesh<'_>{
 			//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(){
+			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;

engine/physics/src/physics.rs

@@ -1,4 +1,5 @@
 use std::collections::{HashMap,HashSet};
+use crate::model::DirectedEdge;
 use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
@@ -15,7 +16,6 @@ pub use strafesnet_common::physics::{Time,TimeInner};
 use gameplay::ModeState;
 
 pub type Body=crate::body::Body<TimeInner>;
-pub type Trajectory=crate::body::Trajectory<TimeInner>;
 type MouseState=strafesnet_common::mouse::MouseState<TimeInner>;
 
 //external influence
@@ -29,7 +29,6 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
-	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -288,7 +287,8 @@ impl PhysicsCamera{
 		.clamp(Self::ANGLE_PITCH_LOWER_LIMIT,Self::ANGLE_PITCH_UPPER_LIMIT);
 		mat3::from_rotation_yx(ax,ay)
 	}
-	fn rotation(&self)->Planar64Mat3{
+	#[inline]
+	pub fn rotation(&self)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos)
 	}
 	#[expect(dead_code)]
@@ -500,24 +500,20 @@ enum MoveState{
 }
 impl MoveState{
 	//call this after state.move_state is changed
-	fn acceleration(&self,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->Planar64Vec3{
+	fn apply_enum(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
-			MoveState::Fly=>vec3::zero(),
-			MoveState::Air
-			|MoveState::Water
-			=>{
-				// calculate base acceleration
-				let base_acceleration=touching.base_acceleration(models,style,camera,input_state);
-				// constrain_acceleration clips according to contacts
-				touching.constrain_acceleration(models,hitbox_mesh,base_acceleration)
+			MoveState::Fly=>body.acceleration=vec3::zero(),
+			MoveState::Air=>{
+				//calculate base acceleration
+				let a=touching.base_acceleration(models,style,camera,input_state);
+				//set_acceleration clips according to contacts
+				set_acceleration(body,touching,models,hitbox_mesh,a);
 			},
-			MoveState::Walk(walk_state)
-			|MoveState::Ladder(walk_state)
-			=>walk_state.target.acceleration(),
+			_=>(),
 		}
 	}
 	//function to coerce &mut self into &self
-	fn update_fly_velocity(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+	fn apply_to_body(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Air=>(),
 			MoveState::Water=>(),
@@ -527,13 +523,17 @@ impl MoveState{
 				//set_velocity clips velocity according to current touching state
 				set_velocity(body,touching,models,hitbox_mesh,v);
 			},
-			MoveState::Walk(_walk_state)
-			|MoveState::Ladder(_walk_state)
-			=>(),
+			MoveState::Walk(walk_state)
+			|MoveState::Ladder(walk_state)
+			=>{
+				//accelerate towards walk target or do nothing
+				let a=walk_state.target.acceleration();
+				set_acceleration(body,touching,models,hitbox_mesh,a);
+			},
 		}
 	}
 	/// changes the move state
-	fn update_walk_target(&mut self,body:&Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+	fn apply_input(&mut self,body:&Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
 			MoveState::Fly
 			|MoveState::Air
@@ -590,11 +590,24 @@ impl MoveState{
 			MoveState::Fly=>None,
 		}
 	}
+	//lmao idk this is convenient
+	fn apply_enum_and_input_and_body(&mut self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+		self.apply_enum(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_input(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_to_body(body,touching,models,hitbox_mesh,style,camera,input_state);
+	}
+	fn apply_enum_and_body(&mut self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+		self.apply_enum(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_to_body(body,touching,models,hitbox_mesh,style,camera,input_state);
+	}
+	fn apply_input_and_body(&mut self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
+		self.apply_input(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_to_body(body,touching,models,hitbox_mesh,style,camera,input_state);
+	}
 	fn set_move_state(&mut self,move_state:MoveState,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		*self=move_state;
 		//this function call reads the above state that was just set
-		self.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-		self.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+		self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
 	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		//TODO: be more precise about contacts
@@ -607,11 +620,10 @@ impl MoveState{
 					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
-					self.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-					self.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+					self.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 				},
 				// not walking, but stopped touching something
-				None=>self.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state),
+				None=>self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state),
 			}
 		}
 	}
@@ -805,7 +817,7 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		crate::push_solve::push_solve(&contacts,velocity).0
+		crate::push_solve::push_solve(&contacts,velocity)
 	}
 	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:Planar64Vec3)->Planar64Vec3{
 		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
@@ -816,17 +828,18 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		crate::push_solve::push_solve(&contacts,acceleration).0
+		crate::push_solve::push_solve(&contacts,acceleration)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,trajectory:&Trajectory,start_time:Time){
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
+		let relative_body=body;
 		for (convex_mesh_id,face_id) in &self.contacts{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_face_out(&trajectory,start_time..collector.time(),*face_id).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),*face_id).map(|(_face,time)|{
 				TimedInstruction{
-					time:trajectory.time+time.into(),
+					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
 						Collision::Contact(ContactCollision{face_id:*face_id,convex_mesh_id:*convex_mesh_id}),
 						time
@@ -838,9 +851,9 @@ impl TouchingState{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&trajectory,start_time..collector.time()).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
 				TimedInstruction{
-					time:trajectory.time+time.into(),
+					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
 						Collision::Intersect(IntersectCollision{convex_mesh_id:*convex_mesh_id}),
 						time
@@ -875,7 +888,7 @@ pub struct PhysicsState{
 impl Default for PhysicsState{
 	fn default()->Self{
  		Self{
-			body:Body::new(vec3::int(0,50,0),vec3::int(0,0,0),Time::ZERO),
+			body:Body::new(vec3::int(0,50,0),vec3::int(0,0,0),vec3::int(0,-100,0),Time::ZERO),
 			time:Time::ZERO,
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
@@ -899,14 +912,11 @@ impl PhysicsState{
 	pub const fn body(&self)->&Body{
 		&self.body
 	}
-	pub fn camera_trajectory(&self,data:&PhysicsData)->Trajectory{
-		let acceleration=self.acceleration(data);
-		Trajectory::new(
-			self.body.position+self.style.camera_offset,
-			self.body.velocity,
-			acceleration,
-			self.body.time,
-		)
+	pub fn camera_body(&self)->Body{
+		Body{
+			position:self.body.position+self.style.camera_offset,
+			..self.body
+		}
 	}
 	pub const fn camera(&self)->PhysicsCamera{
 		self.camera
@@ -935,8 +945,8 @@ impl PhysicsState{
 	fn set_move_state(&mut self,data:&PhysicsData,move_state:MoveState){
 		self.move_state.set_move_state(move_state,&mut self.body,&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
 	}
-	fn acceleration(&self,data:&PhysicsData)->Planar64Vec3{
-		self.move_state.acceleration(&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state)
+	fn apply_input_and_body(&mut self,data:&PhysicsData){
+		self.move_state.apply_input_and_body(&mut self.body,&self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
 	}
 	//state mutated on collision:
 	//Accelerator
@@ -989,6 +999,45 @@ impl PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
+	pub fn trace_ray(&self,ray:strafesnet_common::ray::Ray)->Option<ModelId>{
+		let (_time,convex_mesh_id)=self.bvh.sample_ray(&ray,Time::ZERO,Time::MAX/4,|&model,ray|{
+			let mesh=self.models.mesh(model);
+			// brute force trace every face
+			let faces=mesh.faces().filter_map(|face_id|{
+				let (n,d)=mesh.face_nd(face_id);
+				// trace ray onto face
+				// n.(o+d*t)==n.p
+				// n.o + n.d * t == n.p
+				// t == (n.p - n.o)/n.d
+				let nd=n.dot(ray.direction);
+				if nd.is_zero(){
+					return None;
+				}
+				let t=(d-n.dot(ray.origin))/nd;
+				Some((face_id,t,n))
+			});
+			let mut min=None;
+			for (face_id,t,n) in faces{
+				if let Some(min)=min&&min<t{
+					continue;
+				}
+				// check if point of intersection is behind face edges
+				// *2 because average of 2 vertices
+				let p=ray.extrapolate(t)*2;
+				let is_inside_face=mesh.face_edges(face_id).as_ref().iter().all(|&directed_edge_id|{
+					let edge_n=mesh.directed_edge_n(directed_edge_id);
+					let cross_n=edge_n.cross(n);
+					let &[vert0,vert1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
+					cross_n.dot(p)<cross_n.dot(mesh.vert(vert0)+mesh.vert(vert1))
+				});
+				if is_inside_face{
+					min=Some(t);
+				}
+			}
+			min.map(Into::into)
+		})?;
+		Some(convex_mesh_id.model_id.into())
+	}
 	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
@@ -1183,43 +1232,43 @@ impl<'a> PhysicsContext<'a>{
 	}
 }
 
-//this is the one who asks
-fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
-	//JUST POLLING!!! NO MUTATION
-	let mut collector=instruction::InstructionCollector::new(time_limit);
+	//this is the one who asks
+	fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
+		//JUST POLLING!!! NO MUTATION
+		let mut collector=instruction::InstructionCollector::new(time_limit);
 
-	collector.collect(state.next_move_instruction());
+		collector.collect(state.next_move_instruction());
 
-	let trajectory=state.body.with_acceleration(state.acceleration(data));
-	//check for collision ends
-	state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&trajectory,state.time);
-	//check for collision starts
-	let mut aabb=aabb::Aabb::default();
-	trajectory.grow_aabb(&mut aabb,state.time,collector.time());
-	aabb.inflate(data.hitbox_mesh.halfsize);
-	//relative to moving platforms
-	//let relative_body=state.body.relative_to(&Body::ZERO);
-	data.bvh.sample_aabb(&aabb,&mut |convex_mesh_id|{
-		if state.touching.contains(convex_mesh_id){
-			return;
-		}
-		//no checks are needed because of the time limits.
-		let model_mesh=data.models.mesh(*convex_mesh_id);
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-		collector.collect(minkowski.predict_collision_in(&trajectory,state.time..collector.time())
-			.map(|(face,dt)|
-				TimedInstruction{
-					time:trajectory.time+dt.into(),
-					instruction:InternalInstruction::CollisionStart(
-						Collision::new(*convex_mesh_id,face),
-						dt
-					)
-				}
-			)
-		);
-	});
-	collector.take()
-}
+		//check for collision ends
+		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
+		//check for collision starts
+		let mut aabb=aabb::Aabb::default();
+		state.body.grow_aabb(&mut aabb,state.time,collector.time());
+		aabb.inflate(data.hitbox_mesh.halfsize);
+		//relative to moving platforms
+		//let relative_body=state.body.relative_to(&Body::ZERO);
+		let relative_body=&state.body;
+		data.bvh.sample_aabb(&aabb,&mut |convex_mesh_id|{
+			if state.touching.contains(convex_mesh_id){
+				return;
+			}
+			//no checks are needed because of the time limits.
+			let model_mesh=data.models.mesh(*convex_mesh_id);
+			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
+				.map(|(face,dt)|
+					TimedInstruction{
+						time:relative_body.time+dt.into(),
+						instruction:InternalInstruction::CollisionStart(
+							Collision::new(*convex_mesh_id,face),
+							dt
+						)
+					}
+				)
+			);
+		});
+		collector.take()
+	}
 
 
 fn contact_normal(
@@ -1327,6 +1376,24 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3){
 	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);
 }
+#[expect(dead_code)]
+fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
+	//This is not correct but is better than what I have
+	let mut culled=false;
+	touching.contacts.retain(|convex_mesh_id,face_id|{
+		let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
+		let r=n.dot(a).is_positive();
+		if r{
+			culled=true;
+		}
+		!r
+	});
+	set_acceleration(body,touching,models,hitbox_mesh,a);
+	culled
+}
+fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3){
+	body.acceleration=touching.constrain_acceleration(models,hitbox_mesh,a);
+}
 
 fn teleport(
 	point:Planar64Vec3,
@@ -1345,6 +1412,7 @@ fn teleport(
 	time:Time,
 ){
 	set_position(point,move_state,body,touching,run,mode_state,mode,models,hitbox_mesh,bvh,style,camera,input_state,time);
+	set_acceleration(body,touching,models,hitbox_mesh,style.gravity);
 }
 enum TeleportToSpawnError{
 	NoModel,
@@ -1607,8 +1675,7 @@ fn collision_start_contact(
 	}
 	//doing enum to set the acceleration when surfing
 	//doing input_and_body to refresh the walk state if you hit a wall while accelerating
-	move_state.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-	move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+	move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 }
 
 fn collision_start_intersect(
@@ -1643,20 +1710,7 @@ fn collision_start_intersect(
 			},
 			Some(gameplay_modes::Zone::Finish)=>{
 				match run.finish(time){
-					Ok(())=>{
-						let time=run.time(time);
-						let h=time.get()/(Time::ONE_SECOND.get()*60*60);
-						let m=(time.get()/(Time::ONE_SECOND.get()*60)).rem_euclid(60);
-						let s=(time.get()/(Time::ONE_SECOND.get())).rem_euclid(60);
-						let ms=(time.get()/(Time::ONE_MILLISECOND.get())).rem_euclid(1000);
-						let us=(time.get()/(Time::ONE_MICROSECOND.get())).rem_euclid(1000);
-						let ns=(time.get()/(Time::ONE_NANOSECOND.get())).rem_euclid(1000);
-						if h==0{
-							println!("@@@@ Finished run time={m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
-						}else{
-							println!("@@@@ Finished run time={h}:{m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
-						}
-					},
+					Ok(())=>println!("@@@@ Finished run time={}",run.time(time)),
 					Err(e)=>println!("@@@@ Run Finish error:{e:?}"),
 				}
 			},
@@ -1664,7 +1718,7 @@ fn collision_start_intersect(
 			None=>(),
 		}
 	}
-	move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	run_teleport_behaviour(intersect.convex_mesh_id.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
 }
 
@@ -1692,11 +1746,10 @@ fn collision_end_contact(
 			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 		}else{
 			// stopped touching something else while walking
-			move_state.update_walk_target(body,touching,models,hitbox_mesh,style,camera,input_state);
-			move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+			move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 		},
 		// not walking, but stopped touching something
-		None=>move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state),
+		None=>move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state),
 	}
 }
 fn collision_end_intersect(
@@ -1715,7 +1768,7 @@ fn collision_end_intersect(
 	time:Time,
 ){
 	touching.remove_intersect(convex_mesh_id);
-	move_state.update_fly_velocity(body,touching,models,hitbox_mesh,style,camera,input_state);
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(convex_mesh_id.model_id.into());
 		match zone{
@@ -1731,100 +1784,99 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	match ins.instruction{
-		// collisions advance the body precisely
+	let (should_advance_body,goober_time)=match ins.instruction{
 		InternalInstruction::CollisionStart(_,dt)
-		|InternalInstruction::CollisionEnd(_,dt)=>{
-			state.body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body_ratio_dt(dt);
-		},
-		// this advances imprecisely
-		InternalInstruction::ReachWalkTargetVelocity=>state.body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body(state.time),
-		// strafe tick decides for itself whether to advance the body.
-		InternalInstruction::StrafeTick=>(),
+		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
+		InternalInstruction::StrafeTick
+		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
+	};
+	if should_advance_body{
+		match goober_time{
+			Some(dt)=>state.body.advance_time_ratio_dt(dt),
+			None=>state.body.advance_time(state.time),
+		}
 	}
-	match ins.instruction{
-		InternalInstruction::CollisionStart(collision,_)=>{
-			let mode=data.modes.get_mode(state.mode_state.get_mode_id());
-			match collision{
-				Collision::Contact(contact)=>collision_start_contact(
-					&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,&mut state.run,
-					mode,
-					&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+		match ins.instruction{
+			InternalInstruction::CollisionStart(collision,_)=>{
+				let mode=data.modes.get_mode(state.mode_state.get_mode_id());
+				match collision{
+					Collision::Contact(contact)=>collision_start_contact(
+						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,&mut state.run,
+						mode,
+						&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+						data.models.contact_attr(contact.convex_mesh_id.model_id),
+						contact,
+						state.time,
+					),
+					Collision::Intersect(intersect)=>collision_start_intersect(
+						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,
+						mode,
+						&mut state.run,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+						data.models.intersect_attr(intersect.convex_mesh_id.model_id),
+						intersect,
+						state.time,
+					),
+				}
+			},
+			InternalInstruction::CollisionEnd(collision,_)=>match collision{
+				Collision::Contact(contact)=>collision_end_contact(
+					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.models.contact_attr(contact.convex_mesh_id.model_id),
-					contact,
-					state.time,
+					&contact.convex_mesh_id
 				),
-				Collision::Intersect(intersect)=>collision_start_intersect(
-					&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,
-					mode,
-					&mut state.run,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
+				Collision::Intersect(intersect)=>collision_end_intersect(
+					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
+					data.modes.get_mode(state.mode_state.get_mode_id()),
+					&mut state.run,
 					data.models.intersect_attr(intersect.convex_mesh_id.model_id),
-					intersect,
-					state.time,
+					&intersect.convex_mesh_id,
+					state.time
 				),
-			}
-		},
-		InternalInstruction::CollisionEnd(collision,_)=>match collision{
-			Collision::Contact(contact)=>collision_end_contact(
-				&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
-				data.models.contact_attr(contact.convex_mesh_id.model_id),
-				&contact.convex_mesh_id
-			),
-			Collision::Intersect(intersect)=>collision_end_intersect(
-				&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
-				data.modes.get_mode(state.mode_state.get_mode_id()),
-				&mut state.run,
-				data.models.intersect_attr(intersect.convex_mesh_id.model_id),
-				&intersect.convex_mesh_id,
-				state.time
-			),
-		},
-		InternalInstruction::StrafeTick=>{
-			//TODO make this less huge
-			if let Some(strafe_settings)=&state.style.strafe{
-				let controls=state.input_state.controls;
-				if strafe_settings.activates(controls){
-					let masked_controls=strafe_settings.mask(controls);
-					let control_dir=state.style.get_control_dir(masked_controls);
-					if control_dir!=vec3::zero(){
-						// manually advance time
-						let extrapolated_body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body(state.time);
-						let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
-						if let Some(ticked_velocity)=strafe_settings.tick_velocity(extrapolated_body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
-							state.body=extrapolated_body;
-							//this is wrong but will work ig
-							//need to note which push planes activate in push solve and keep those
-							state.cull_velocity(data,ticked_velocity);
+			},
+			InternalInstruction::StrafeTick=>{
+				//TODO make this less huge
+				if let Some(strafe_settings)=&state.style.strafe{
+					let controls=state.input_state.controls;
+					if strafe_settings.activates(controls){
+						let masked_controls=strafe_settings.mask(controls);
+						let control_dir=state.style.get_control_dir(masked_controls);
+						if control_dir!=vec3::zero(){
+							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
+							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
+								//this is wrong but will work ig
+								//need to note which push planes activate in push solve and keep those
+								state.cull_velocity(data,ticked_velocity);
+							}
 						}
 					}
 				}
 			}
-		}
-		InternalInstruction::ReachWalkTargetVelocity=>{
-			match &mut state.move_state{
-				MoveState::Air
-				|MoveState::Water
-				|MoveState::Fly
-				=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
-				MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>{
-					//velocity is already handled by extrapolated_body
-					//we know that the acceleration is precisely zero because the walk target is known to be reachable
-					//which means that gravity can be fully cancelled
-					//ignore moving platforms for now
-					let target=core::mem::replace(&mut walk_state.target,TransientAcceleration::Reached);
-					// check what the target was to see if it was invalid
-					match target{
-						//you are not supposed to reach a walk target which is already reached!
-						TransientAcceleration::Reached=>println!("Invalid walk target: Reached"),
-						TransientAcceleration::Reachable{..}=>(),
-						//you are not supposed to reach an unreachable walk target!
-						TransientAcceleration::Unreachable{..}=>println!("Invalid walk target: Unreachable"),
+			InternalInstruction::ReachWalkTargetVelocity=>{
+				match &mut state.move_state{
+					MoveState::Air
+					|MoveState::Water
+					|MoveState::Fly
+					=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
+					MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>{
+						//velocity is already handled by advance_time
+						//we know that the acceleration is precisely zero because the walk target is known to be reachable
+						//which means that gravity can be fully cancelled
+						//ignore moving platforms for now
+						let target=core::mem::replace(&mut walk_state.target,TransientAcceleration::Reached);
+						set_acceleration(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::zero());
+						// check what the target was to see if it was invalid
+						match target{
+							//you are not supposed to reach a walk target which is already reached!
+							TransientAcceleration::Reached=>println!("Invalid walk target: Reached"),
+							TransientAcceleration::Reachable{..}=>(),
+							//you are not supposed to reach an unreachable walk target!
+							TransientAcceleration::Unreachable{..}=>println!("Invalid walk target: Unreachable"),
+						}
 					}
 				}
-			}
-		},
+			},
+		}
 	}
-}
 
 fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<Instruction,Time>){
 	state.time=ins.time;
@@ -1850,7 +1902,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Misc(MiscInstruction::PracticeFly)=>true,
 	};
 	if should_advance_body{
-		state.body=state.body.with_acceleration(state.acceleration(data)).extrapolated_body(state.time);
+		state.body.advance_time(state.time);
 	}
 
 	let mut b_refresh_walk_target=true;
@@ -1886,9 +1938,6 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			state.input_state.set_control(Controls::Zoom,s);
 			b_refresh_walk_target=false;
 		},
-		Instruction::SetControl(SetControlInstruction::SetSprint(s))=>{
-			state.input_state.set_control(Controls::Sprint,s);
-		},
 		Instruction::Mode(ModeInstruction::Reset)=>{
 			//totally reset physics state
 			state.reset_to_default();
@@ -1948,8 +1997,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 	}
 	if b_refresh_walk_target{
-		state.move_state.update_walk_target(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state);
-		state.move_state.update_fly_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state);
+		state.apply_input_and_body(data);
 		state.cull_velocity(data,state.body.velocity);
 		//also check if accelerating away from surface
 	}
@@ -1959,16 +2007,16 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 mod test{
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};
 	use super::*;
-	fn test_collision_axis_aligned(relative_body:Trajectory,expected_collision_time:Option<Time>){
+	fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
 		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),integer::Planar64Affine3::new(mat3::from_diagonal(int3(5,1,5)>>1),vec3::zero()));
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,..);
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
-	fn test_collision_rotated(relative_body:Trajectory,expected_collision_time:Option<Time>){
+	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
 		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),
 			integer::Planar64Affine3::new(
 				Planar64Mat3::from_cols([
@@ -1983,16 +2031,16 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,..);
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
-	fn test_collision(relative_body:Trajectory,expected_collision_time:Option<Time>){
+	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
 		test_collision_axis_aligned(relative_body,expected_collision_time);
 		test_collision_rotated(relative_body,expected_collision_time);
 	}
 	#[test]
 	fn test_collision_degenerate_straight_down(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2001,7 +2049,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_small_mv(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0)+(vec3::X>>32),
 			vec3::zero(),
@@ -2010,7 +2058,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_east(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(3,5,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2019,7 +2067,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_south(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,3),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2028,7 +2076,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_west(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-3,5,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2037,7 +2085,7 @@ mod test{
 	}
 	#[test]
 	fn test_collision_degenerate_north(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,-3),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2046,115 +2094,115 @@ mod test{
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_west(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(3,3,0),
 			int3(100,-1,0),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_north(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,3,3),
 			int3(0,-1,100),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_east(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-3,3,0),
 			int3(-100,-1,0),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_south(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,3,-3),
 			int3(0,-1,-100),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_ne(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,-7)>>1,
 			int3(-10,-1,1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_nw(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,-7)>>1,
 			int3(10,-1,1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_se(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(7,6,0)>>1,
 			int3(-1,-1,-10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_ne(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(7,6,0)>>1,
 			int3(-1,-1,10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_se(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,7)>>1,
 			int3(-10,-1,-1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_sw(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,6,7)>>1,
 			int3(10,-1,-1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_se(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-7,6,0)>>1,
 			int3(1,-1,-10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_ne(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(-7,6,0)>>1,
 			int3(1,-1,10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Trajectory::ZERO,Time::from_secs(-1)),Some(Time::from_secs(0)));
+		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_oblique(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,5,0),
 			int3(1,-64,2)>>6,// /64
 			vec3::zero(),
@@ -2163,7 +2211,7 @@ mod test{
 	}
 	#[test]
 	fn zoom_hit_nothing(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			int3(0,10,0),
 			int3(1,0,0),
 			int3(0,1,0),
@@ -2172,7 +2220,7 @@ mod test{
 	}
 	#[test]
 	fn already_inside_hit_nothing(){
-		test_collision(Trajectory::new(
+		test_collision(Body::new(
 			vec3::zero(),
 			int3(1,0,0),
 			int3(0,1,0),
@@ -2182,7 +2230,7 @@ mod test{
 	// overlap edges by 1 epsilon
 	#[test]
 	fn almost_miss_north(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)+vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2191,7 +2239,7 @@ mod test{
 	}
 	#[test]
 	fn almost_miss_east(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)+vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2200,7 +2248,7 @@ mod test{
 	}
 	#[test]
 	fn almost_miss_south(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)+vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2209,7 +2257,7 @@ mod test{
 	}
 	#[test]
 	fn almost_miss_west(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)+vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2219,7 +2267,7 @@ mod test{
 	// exactly miss edges
 	#[test]
 	fn exact_miss_north(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(0,10,-7)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2228,7 +2276,7 @@ mod test{
 	}
 	#[test]
 	fn exact_miss_east(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(7,10,0)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2237,7 +2285,7 @@ mod test{
 	}
 	#[test]
 	fn exact_miss_south(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(0,10,7)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2246,7 +2294,7 @@ mod test{
 	}
 	#[test]
 	fn exact_miss_west(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			int3(-7,10,0)>>1,
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2256,7 +2304,7 @@ mod test{
 	// miss edges by 1 epsilon
 	#[test]
 	fn narrow_miss_north(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)-vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2265,7 +2313,7 @@ mod test{
 	}
 	#[test]
 	fn narrow_miss_east(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)-vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2274,7 +2322,7 @@ mod test{
 	}
 	#[test]
 	fn narrow_miss_south(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)-vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
 			vec3::zero(),
@@ -2283,7 +2331,7 @@ mod test{
 	}
 	#[test]
 	fn narrow_miss_west(){
-		test_collision_axis_aligned(Trajectory::new(
+		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)-vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
 			vec3::zero(),

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/src/session.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use strafesnet_common::gameplay_modes::{ModeId,StageId};
 use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,InstructionFeedback,TimedInstruction};
+use strafesnet_common::model::ModelId;
 // session represents the non-hardware state of the client.
 // Ideally it is a deterministic state which is atomically updated by instructions, same as the simulation state.
 use strafesnet_common::physics::{
@@ -52,14 +53,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,
+	pub debug_model:Option<ModelId>,
 }
 
 pub struct Simulation{
@@ -76,11 +79,12 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime,data:&PhysicsData)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime,debug_model:Option<ModelId>)->FrameState{
 		FrameState{
-			trajectory:self.physics.camera_trajectory(data),
+			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
+			debug_model,
 		}
 	}
 }
@@ -160,6 +164,7 @@ pub struct Session{
 	recording:Recording,
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
+	last_ray_hit:Option<ModelId>,
 }
 impl Session{
 	pub fn new(
@@ -176,6 +181,7 @@ impl Session{
 			view_state:ViewState::Play,
 			recording:Default::default(),
 			replays:HashMap::new(),
+			last_ray_hit:None,
 		}
 	}
 	fn clear_recording(&mut self){
@@ -187,12 +193,25 @@ 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,self.last_ray_hit)),
 			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,None)
 			),
 		}
 	}
+	pub fn debug_raycast_print_model_id_if_changed(&mut self,time:SessionTime){
+		if let Some(frame_state)=self.get_frame_state(time){
+			let ray=strafesnet_common::ray::Ray{
+				origin:frame_state.body.extrapolated_position(self.simulation.timer.time(time)),
+				direction:-frame_state.camera.rotation().z_axis,
+			};
+			let model_id=self.geometry_shared.trace_ray(ray);
+			if model_id!=self.last_ray_hit{
+				println!("hit={model_id:?}");
+				self.last_ray_hit=model_id;
+			}
+		}
+	}
 	pub fn user_settings(&self)->&UserSettings{
 		&self.user_settings
 	}
@@ -238,16 +257,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));
@@ -256,14 +271,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
@@ -384,6 +392,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);

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/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/dag/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "dag"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-
-[lints]
-workspace = true

lib/dag/src/lib.rs

@@ -1,16 +0,0 @@
-// typestate dag with lazy just-in-time execution
-struct States<S1,S2>(S1,S2);
-
-struct Known<T>(T);
-struct NeedsRecalculate;
-
-fn a(){
-	// Construct a DAG such that S2 depends on S1
-	// let dag=Dag:new();
-	// Initial state
-	let state=States(Known(1),Known(1));
-	// set_state1 changes S2 to NeedsRecalculate
-	state.set_state1(2);
-	// get_state2 calculates S2
-	let s2=state.get_state2();
-}

lib/rbx_loader/Cargo.toml

@@ -12,7 +12,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
+regex = { version = "1.11.3", default-features = false }
 rbx_mesh = "0.5.0"
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }

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(

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/physics_worker.rs

@@ -77,5 +77,8 @@ pub fn new<'a>(
 				run_session_instruction!(ins.time,SessionInstruction::LoadReplay(bot));
 			}
 		}
+
+		//whatever just do it
+		session.debug_raycast_print_model_id_if_changed(ins.time);
 	})
 }

strafe-client/src/shader.wgsl

@@ -86,6 +86,29 @@ fn vs_entity_texture(
 	return result;
 }
 
+@group(1)
+@binding(0)
+var<uniform> model_instance: ModelInstance;
+
+struct DebugEntityOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(1) normal: vec3<f32>,
+	@location(2) view: vec3<f32>,
+};
+
+@vertex
+fn vs_debug(
+	@location(0) pos: vec3<f32>,
+	@location(1) normal: vec3<f32>,
+) -> DebugEntityOutput {
+	var position: vec4<f32> = model_instance.transform * vec4<f32>(pos, 1.0);
+	var result: DebugEntityOutput;
+	result.normal = model_instance.normal_transform * normal;
+	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
+	result.position = camera.proj * camera.view * position;
+	return result;
+}
+
 //group 2 is the skybox texture
 @group(1)
 @binding(0)
@@ -110,3 +133,8 @@ fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
 	let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
 	return mix(vec4<f32>(vec3<f32>(0.05) + 0.2 * reflected_color,1.0),mix(vertex.model_color,vec4<f32>(fragment_color.rgb,1.0),fragment_color.a),0.5+0.5*abs(d));
 }
+
+@fragment
+fn fs_debug(vertex: DebugEntityOutput) -> @location(0) vec4<f32> {
+	return model_instance.color;
+}

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),
@@ -258,7 +241,6 @@ pub fn worker<'a>(
 	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,