negative everything

make hint_point consistent with vert
load source once at runtime
2025-11-26 13:20:56 -08:00 · 2025-11-26 12:30:06 -08:00 · 2025-11-26 11:47:53 -08:00 · 2025-11-26 11:29:46 -08:00 · 2025-11-26 11:09:59 -08:00 · 2025-11-26 11:09:59 -08:00
30 changed files with 13130 additions and 1865 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/engine/graphics/Cargo.toml
+++ b/engine/graphics/Cargo.toml
@@ -9,11 +9,9 @@ ddsfile = "0.5.1"
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-strafesnet_physics = { path = "../physics", registry = "strafesnet" }
-strafesnet_rbx_loader = { path = "../../lib/rbx_loader", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "28.0.0"
+wgpu = "27.0.0"

 [lints]
 workspace = true
--- a/engine/graphics/src/graphics.rs
+++ b/engine/graphics/src/graphics.rs
@@ -5,20 +5,10 @@ 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,DebugGraphicsVertex};
+use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};

 pub fn required_limits()->wgpu::Limits{
-	let mut limits=wgpu::Limits::default();
-	limits.max_task_invocations_per_dimension=1;
-	limits.max_task_invocations_per_workgroup=1;
-	limits.max_mesh_invocations_per_dimension=1;
-	limits.max_mesh_invocations_per_workgroup=1;
-	limits.max_task_mesh_workgroup_total_count=1;
-	limits.max_task_mesh_workgroups_per_dimension=1;
-	limits.max_task_payload_size=4;
-	limits.max_mesh_output_vertices=2*(3+2+4+8);
-	limits.max_mesh_output_primitives=2*(1+2+4+8)+2;
-	limits
+	wgpu::Limits::default()
 }

 struct Indices{
@@ -46,135 +36,12 @@ struct GraphicsModel{
 	instance_count:u32,
 }

-struct DebugGraphicsSubmesh{
-	verts:Vec<strafesnet_physics::model::MeshVertId>,
-	edges:Vec<[strafesnet_physics::model::MeshVertId;2]>,
-	faces:Vec<Indices>,
-}
-struct DebugGraphicsMesh{
-	vertices:Vec<DebugGraphicsVertex>,
-	indices:Indices,
-	submeshes:Vec<DebugGraphicsSubmesh>,
-	vertex_buf:wgpu::Buffer,
-}
-impl DebugGraphicsMesh{
-	fn new(device:&wgpu::Device,mesh:&model::Mesh)->Self{
-		let vertices:Vec<DebugGraphicsVertex>=mesh.unique_pos.iter().copied().map(|pos|{
-			DebugGraphicsVertex{
-				pos:pos.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,
-		});
-
-		macro_rules! indices{
-			($indices:expr)=>{
-				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)
-				}
-			};
-		}
-
-
-		let mut all_indices=Vec::new();
-
-		let submeshes=if let Ok(physics_mesh)=strafesnet_physics::model::PhysicsMesh::try_from(mesh){
-			physics_mesh.submesh_views().into_iter().map(|submesh_view|DebugGraphicsSubmesh{
-				verts:submesh_view.verts().to_owned(),
-				edges:submesh_view.edge_vert_ids_iter().collect(),
-				faces:submesh_view.face_vert_ids_iter().map(|face_verts|{
-					// triangulate
-					let mut indices=Vec::new();
-					let mut poly_vertices=face_verts.into_iter();
-					if let (Some(a),Some(mut b))=(poly_vertices.next(),poly_vertices.next()){
-						for c in poly_vertices{
-							indices.extend([a,b,c]);
-							all_indices.extend([a,b,c]);
-							b=c;
-						}
-					}
-					indices!(indices)
-				}).collect(),
-			}).collect()
-		}else{
-			//idc
-			Vec::new()
-		};
-
-		let indices=indices!(all_indices);
-
-		DebugGraphicsMesh{
-			vertices,
-			indices,
-			submeshes,
-			vertex_buf,
-		}
-	}
-}
-
-struct DebugGraphicsModel{
-	debug_mesh_id:u32,
-	bind_group:wgpu::BindGroup,
-	// 32 bytes used to tell the mesh shader where to draw
-	// Vert: [vec4,_]
-	// Edge: [vec4,vec4]
-	debug_buf:wgpu::Buffer,
-	model_buf:wgpu::Buffer,
-}
-impl DebugGraphicsModel{
-	fn new(device:&wgpu::Device,layout:&wgpu::BindGroupLayout,model:&model::Model,model_id:usize,color:glam::Vec4)->Self{
-		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(color),
-		}]);
-		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 debug_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
-			label:Some(format!("Debug Model{} EV Buf",model_id).as_str()),
-			contents:bytemuck::cast_slice(&[0u8;32]),
-			usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
-		});
-		let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
-			layout,
-			entries:&[
-				wgpu::BindGroupEntry{
-					binding:0,
-					resource:model_buf.as_entire_binding(),
-				},
-				wgpu::BindGroupEntry{
-					binding:1,
-					resource:debug_buf.as_entire_binding(),
-				},
-			],
-			label:Some(format!("Debug Model{} Bind Group",model_id).as_str()),
-		});
-		DebugGraphicsModel{
-			debug_mesh_id:model.mesh.get(),
-			bind_group,
-			debug_buf,
-			model_buf,
-		}
-	}
-}
-
 struct GraphicsSamplers{
 	repeat:wgpu::Sampler,
 }

 struct GraphicsBindGroupLayouts{
 	model:wgpu::BindGroupLayout,
-	debug_model:wgpu::BindGroupLayout,
 }

 struct GraphicsBindGroups{
@@ -185,9 +52,6 @@ struct GraphicsBindGroups{
 struct GraphicsPipelines{
 	skybox:wgpu::RenderPipeline,
 	model:wgpu::RenderPipeline,
-	debug:wgpu::RenderPipeline,
-	debug_edge:wgpu::RenderPipeline,
-	debug_vert:wgpu::RenderPipeline,
 }

 struct GraphicsCamera{
@@ -268,10 +132,6 @@ pub struct GraphicsState{
 	camera_buf:wgpu::Buffer,
 	temp_squid_texture_view:wgpu::TextureView,
 	models:Vec<GraphicsModel>,
-	debug_meshes:Vec<DebugGraphicsMesh>,
-	debug_models:Vec<DebugGraphicsModel>,
-	hitbox_mesh:DebugGraphicsMesh,
-	hitbox_model:DebugGraphicsModel,
 	depth_view:wgpu::TextureView,
 	staging_belt:wgpu::util::StagingBelt,
 }
@@ -306,16 +166,6 @@ 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|
-			DebugGraphicsMesh::new(device,mesh)
-		).collect();
-
-		//generate debug models, only one will be rendered at a time
-		self.debug_models=map.models.iter().enumerate().map(|(model_id,model)|{
-			DebugGraphicsModel::new(device,&self.bind_group_layouts.debug_model,model,model_id,glam::vec4(1.0,0.0,0.0,0.2))
-		}).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);
@@ -696,7 +546,7 @@ impl GraphicsState{
 			entries:&[
 				wgpu::BindGroupLayoutEntry{
 					binding:0,
-					visibility:wgpu::ShaderStages::VERTEX|wgpu::ShaderStages::MESH,
+					visibility:wgpu::ShaderStages::VERTEX,
 					ty:wgpu::BindingType::Buffer{
 						ty:wgpu::BufferBindingType::Uniform,
 						has_dynamic_offset:false,
@@ -758,31 +608,6 @@ 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|wgpu::ShaderStages::MESH,
-					ty:wgpu::BindingType::Buffer{
-						ty:wgpu::BufferBindingType::Uniform,
-						has_dynamic_offset:false,
-						min_binding_size:None,
-					},
-					count:None,
-				},
-				wgpu::BindGroupLayoutEntry{
-					binding:1,
-					visibility:wgpu::ShaderStages::MESH,
-					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"),
@@ -791,7 +616,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::ClampToEdge,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::MipmapFilterMode::Linear,
+			mipmap_filter:wgpu::FilterMode::Linear,
 			..Default::default()
 		});
 		let repeat_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
@@ -801,7 +626,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::Repeat,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::MipmapFilterMode::Linear,
+			mipmap_filter:wgpu::FilterMode::Linear,
 			anisotropy_clamp:16,
 			..Default::default()
 		});
@@ -929,23 +754,15 @@ impl GraphicsState{
 				&skybox_texture_bind_group_layout,
 				&model_bind_group_layout,
 			],
-			immediate_size:0,
+			push_constant_ranges:&[],
 		});
-		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,
-				],
-				immediate_size:0,
-			});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
 			bind_group_layouts:&[
 				&camera_bind_group_layout,
 				&skybox_texture_bind_group_layout,
 			],
-			immediate_size:0,
+			push_constant_ranges:&[],
 		});

 		// Create the render pipelines
@@ -976,7 +793,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
+			multiview:None,
 			cache:None,
 		});
 		let model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
@@ -1011,95 +828,9 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
-			cache:None,
-		});
-		let debug_model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
-			label:Some("Debug 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],
-				}],
-				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{
-				topology:wgpu::PrimitiveTopology::TriangleList,
-				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::LessEqual,
-				stencil:wgpu::StencilState::default(),
-				bias:wgpu::DepthBiasState::default(),
-			}),
-			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
-			cache:None,
-		});
-		let mut debug_model_pipeline_ms=wgpu::MeshPipelineDescriptor{
-			label:None,//filled in below
-			layout:Some(&debug_model_pipeline_layout),
-			task:Some(wgpu::TaskState{
-				module:&shader,
-				entry_point:Some("ts_main"),
-				compilation_options:wgpu::PipelineCompilationOptions::default(),
-			}),
-			mesh:wgpu::MeshState{
-				module:&shader,
-				entry_point:None,//filled in below
-				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{
-				topology:wgpu::PrimitiveTopology::TriangleList,
-				front_face:wgpu::FrontFace::Cw,
-				cull_mode:None,
-				..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,
-		};
-		debug_model_pipeline_ms.label=Some("Debug Vert Pipeline");
-		debug_model_pipeline_ms.mesh.entry_point=Some("ms_debug_vert");
-		let debug_model_pipeline_vert=device.create_mesh_pipeline(&debug_model_pipeline_ms);
-		debug_model_pipeline_ms.label=Some("Debug Edge Pipeline");
-		debug_model_pipeline_ms.mesh.entry_point=Some("ms_debug_edge");
-		let debug_model_pipeline_edge=device.create_mesh_pipeline(&debug_model_pipeline_ms);
+		});

 		let camera=GraphicsCamera::default();
 		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
@@ -1136,23 +867,10 @@ impl GraphicsState{

 		let depth_view=Self::create_depth_texture(config,device);

-		// WHIP UP A CUBE
-		let cube_face_description=strafesnet_rbx_loader::primitives::CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
-		let hitbox_mesh=DebugGraphicsMesh::new(device,&strafesnet_rbx_loader::primitives::unit_cube(cube_face_description));
-		let hitbox_model=DebugGraphicsModel::new(device,&debug_model_bind_group_layout,&model::Model{
-			mesh:model::MeshId::new(u32::MAX),
-			attributes:strafesnet_common::gameplay_attributes::CollisionAttributesId::new(0),
-			color:glam::Vec4::new(0.0,0.0,1.0,0.2),
-			transform:strafesnet_common::integer::Planar64Affine3::IDENTITY,
-		},u32::MAX as usize,glam::vec4(0.0,1.0,0.0,0.2));
-
 		Self{
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
-				model:model_pipeline,
-				debug:debug_model_pipeline,
-				debug_edge:debug_model_pipeline_edge,
-				debug_vert:debug_model_pipeline_vert,
+				model:model_pipeline
 			},
 			bind_groups:GraphicsBindGroups{
 				camera:camera_bind_group,
@@ -1161,16 +879,9 @@ impl GraphicsState{
 			camera,
 			camera_buf,
 			models:Vec::new(),
-			debug_meshes:Vec::new(),
-			debug_models:Vec::new(),
-			hitbox_mesh,
-			hitbox_model,
 			depth_view,
-			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
-			bind_group_layouts:GraphicsBindGroupLayouts{
-				model:model_bind_group_layout,
-				debug_model:debug_model_bind_group_layout,
-			},
+			staging_belt:wgpu::util::StagingBelt::new(0x100),
+			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
 		}
@@ -1207,6 +918,7 @@ impl GraphicsState{
 				&self.camera_buf,
 				0,
 				wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
+				device,
 			)
 			.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
 		//This code only needs to run when the uniforms change
@@ -1224,66 +936,6 @@ impl GraphicsState{
 				.copy_from_slice(bytemuck::cast_slice(&model_uniforms));
 		}
 		*/
-
-		// update hitbox mesh transform
-		if let Some(debug_hitbox_position)=frame_state.debug_hitbox_position{
-			let model_uniforms=get_instances_buffer_data(&[GraphicsModelOwned{
-				transform:debug_hitbox_position.into(),
-				normal_transform:glam::Mat3::IDENTITY,
-				color:GraphicsModelColor4::new(glam::vec4(1.0,0.0,0.0,0.2)),
-			}]);
-			let debug_slice=bytemuck::cast_slice(&model_uniforms);
-			self.staging_belt.write_buffer(
-				&mut encoder,
-				&self.hitbox_model.model_buf,
-				0,
-				wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
-			).copy_from_slice(debug_slice);
-		}
-
-		// upload the edge or vertex for the mesh shader to highlight
-		if let Some(hit)=&frame_state.hit{
-			if let Some(closest_fev)=&hit.closest_fev{
-				let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
-				if let Some(model)=self.debug_models.get(model_id.get() as usize){
-					let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
-					match closest_fev{
-						strafesnet_physics::model::FEV::Face(_face)=>{
-							// face is rendered normally
-						},
-						strafesnet_physics::model::FEV::Edge(edge)=>{
-							let [v0_id,v1_id]=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].edges[edge.get() as usize];
-							let v0_pos=mesh.vertices[v0_id.get() as usize].pos;
-							let v1_pos=mesh.vertices[v1_id.get() as usize].pos;
-							let debug_data=[glam::Vec3A::from_array(v0_pos).extend(1.0).to_array(),glam::Vec3A::from_array(v1_pos).extend(1.0).to_array()];
-							let debug_slice=bytemuck::cast_slice(&debug_data);
-							self.staging_belt
-								.write_buffer(
-									&mut encoder,
-									&model.debug_buf,
-									0,
-									wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
-								)
-								.copy_from_slice(debug_slice);
-						},
-						strafesnet_physics::model::FEV::Vert(vert)=>{
-							let vert_id=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].verts[vert.get() as usize].get();
-							let pos=mesh.vertices[vert_id as usize].pos;
-							let debug_data=[glam::Vec3A::from_array(pos).extend(1.0).to_array()];
-							let debug_slice=bytemuck::cast_slice(&debug_data);
-							self.staging_belt
-								.write_buffer(
-									&mut encoder,
-									&model.debug_buf,
-									0,
-									wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
-								)
-								.copy_from_slice(debug_slice);
-						},
-					}
-				}
-			}
-		}
 		self.staging_belt.finish();

 		{
@@ -1313,13 +965,11 @@ impl GraphicsState{
 				}),
 				timestamp_writes:Default::default(),
 				occlusion_query_set:Default::default(),
-				multiview_mask:None,
 			});

 			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,&[]);
@@ -1331,46 +981,6 @@ impl GraphicsState{

 			rpass.set_pipeline(&self.pipelines.skybox);
 			rpass.draw(0..3,0..1);
-
-			// render a single debug_model in red
-			if let Some(hit)=&frame_state.hit{
-				if let Some(closest_fev)=&hit.closest_fev{
-					let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
-					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_bind_group(1,&model.bind_group,&[]);
-						rpass.set_vertex_buffer(0,mesh.vertex_buf.slice(..));
-						match closest_fev{
-							strafesnet_physics::model::FEV::Face(face)=>{
-								rpass.set_pipeline(&self.pipelines.debug);
-								let indices=&mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].faces[face.get() as usize];
-								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
-								//TODO: loop over triangle strips
-								rpass.draw_indexed(0..indices.count,0,0..1);
-							},
-							strafesnet_physics::model::FEV::Edge(_edge)=>{
-								rpass.set_pipeline(&self.pipelines.debug_edge);
-								// the data has already been primed by the staging belt
-								rpass.draw_mesh_tasks(1, 1, 1);
-							},
-							strafesnet_physics::model::FEV::Vert(_vert)=>{
-								rpass.set_pipeline(&self.pipelines.debug_vert);
-								// the data has already been primed by the staging belt
-								rpass.draw_mesh_tasks(1, 1, 1);
-							},
-						}
-					}
-				}
-			}
-
-			if frame_state.debug_hitbox_position.is_some(){
-				rpass.set_bind_group(1,&self.hitbox_model.bind_group,&[]);
-				rpass.set_vertex_buffer(0,self.hitbox_mesh.vertex_buf.slice(..));
-				rpass.set_pipeline(&self.pipelines.debug);
-				rpass.set_index_buffer(self.hitbox_mesh.indices.buf.slice(..),self.hitbox_mesh.indices.format);
-				//TODO: loop over triangle strips
-				rpass.draw_indexed(0..self.hitbox_mesh.indices.count,0,0..1);
-			}
 		}

 		queue.submit(std::iter::once(encoder.finish()));
--- a/engine/graphics/src/model.rs
+++ b/engine/graphics/src/model.rs
@@ -8,11 +8,6 @@ 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],
-}
 #[derive(Clone,Copy,id::Id)]
 pub struct IndexedGraphicsMeshOwnedRenderConfigId(u32);
 pub struct IndexedGraphicsMeshOwnedRenderConfig{
--- a/engine/physics/Cargo.toml
+++ b/engine/physics/Cargo.toml
@@ -7,6 +7,7 @@ edition = "2024"
 arrayvec = "0.7.6"
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
+mlua = { version = "0.11.5", features = ["luau"] }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

 [lints]
--- a/engine/physics/src/face_crawler.rs
+++ b/engine/physics/src/face_crawler.rs
@@ -15,18 +15,18 @@ pub enum CrawlResult<M:MeshQuery>{
 	Hit(M::Face,GigaTime),
 }
 impl<M:MeshQuery> CrawlResult<M>{
-	pub fn fev(self)->FEV<M>{
-		match self{
-			CrawlResult::Miss(fev)=>fev,
-			CrawlResult::Hit(face,_)=>FEV::Face(face),
-		}
-	}
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,
 			CrawlResult::Hit(face,time)=>Some((face,time)),
 		}
 	}
+	pub fn miss(self)->Option<FEV<M>>{
+		match self{
+			CrawlResult::Miss(fev)=>Some(fev),
+			CrawlResult::Hit(_,_)=>None,
+		}
+	}
 }

 // TODO: move predict_collision_face_out algorithm in here or something
--- a/engine/physics/src/lib.rs
+++ b/engine/physics/src/lib.rs
@@ -1,8 +1,9 @@
 mod body;
 mod face_crawler;
-pub mod model;
+mod model;
 mod push_solve;
 mod minimum_difference;
+mod minimum_difference_lua;

 pub mod physics;

--- a/engine/physics/src/minimum_difference.rs
+++ b/engine/physics/src/minimum_difference.rs
@@ -1,23 +1,20 @@
 use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
+use strafesnet_common::integer::{Fixed,Planar64Vec3};

-use crate::model::{DirectedEdge,FEV,MeshQuery};
-// TODO: remove mesh invert
-use crate::model::{MinkowskiMesh,MinkowskiVert};
+use crate::model::{MeshQuery,MinkowskiMesh,MinkowskiVert};

 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021

-type Simplex<const N:usize,Vert>=[Vert;N];
-#[derive(Clone,Copy)]
-enum Simplex1_3<Vert>{
-	Simplex1(Simplex<1,Vert>),
-	Simplex2(Simplex<2,Vert>),
-	Simplex3(Simplex<3,Vert>),
+type Simplex<const N:usize>=[MinkowskiVert;N];
+enum Simplex1_3{
+	Simplex1(Simplex<1>),
+	Simplex2(Simplex<2>),
+	Simplex3(Simplex<3>),
 }
-impl<Vert> Simplex1_3<Vert>{
-	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
+impl Simplex1_3{
+	fn push_front(self,v:MinkowskiVert)->Simplex2_4{
 		match self{
 			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
 			Simplex1_3::Simplex2([v0,v1])=>Simplex2_4::Simplex3([v,v0,v1]),
@@ -25,11 +22,10 @@ impl<Vert> Simplex1_3<Vert>{
 		}
 	}
 }
-#[derive(Clone,Copy)]
-enum Simplex2_4<Vert>{
-	Simplex2(Simplex<2,Vert>),
-	Simplex3(Simplex<3,Vert>),
-	Simplex4(Simplex<4,Vert>),
+enum Simplex2_4{
+	Simplex2(Simplex<2>),
+	Simplex3(Simplex<3>),
+	Simplex4(Simplex<4>),
 }

 /*
@@ -45,23 +41,23 @@ local function absDet(r, u, v, w)
 	end
 end
 */
-impl<Vert> Simplex2_4<Vert>{
-	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
+impl Simplex2_4{
+	fn det_is_zero(&self,mesh:&MinkowskiMesh)->bool{
 		match self{
-			Self::Simplex4([p0,p1,p2,p3])=>{
+			&Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				let p2=mesh.vert(p2);
 				let p3=mesh.vert(p3);
 				(p1-p0).cross(p2-p0).dot(p3-p0)==Fixed::ZERO
 			},
-			Self::Simplex3([p0,p1,p2])=>{
+			&Self::Simplex3([p0,p1,p2])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				let p2=mesh.vert(p2);
 				(p1-p0).cross(p2-p0)==vec3::zero()
 			},
-			Self::Simplex2([p0,p1])=>{
+			&Self::Simplex2([p0,p1])=>{
 				let p0=mesh.vert(p0);
 				let p1=mesh.vert(p1);
 				p1-p0==vec3::zero()
@@ -100,45 +96,14 @@ const fn choose_any_direction()->Planar64Vec3{
 	vec3::X
 }

-fn narrow_dir2(dir:Vector3<Fixed<2,64>>)->Planar64Vec3{
-	if dir==vec3::zero(){
-		return dir.narrow_1().unwrap();
-	}
-	let x=dir.x.as_bits().unsigned_abs().bits();
-	let y=dir.y.as_bits().unsigned_abs().bits();
-	let z=dir.z.as_bits().unsigned_abs().bits();
-	let big=x.max(y).max(z);
-	const MAX_BITS:u32=64+31;
-	if MAX_BITS<big{
-		dir>>(big-MAX_BITS)
-	}else{
-		dir
-	}.narrow_1().unwrap()
-}
-fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
-	if dir==vec3::zero(){
-		return dir.narrow_1().unwrap();
-	}
-	let x=dir.x.as_bits().unsigned_abs().bits();
-	let y=dir.y.as_bits().unsigned_abs().bits();
-	let z=dir.z.as_bits().unsigned_abs().bits();
-	let big=x.max(y).max(z);
-	const MAX_BITS:u32=96+31;
-	if MAX_BITS<big{
-		dir>>(big-MAX_BITS)
-	}else{
-		dir
-	}.narrow_1().unwrap()
-}
-
-fn reduce1<M:MeshQuery>(
-	[v0]:Simplex<1,M::Vert>,
-	mesh:&M,
+fn reduce1(
+	[v0]:Simplex<1>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
-	let p0=mesh.vert(v0);
+	let p0=-mesh.vert(v0);

 	// local p = -a
 	let p=-(p0+point);
@@ -160,16 +125,16 @@ fn reduce1<M:MeshQuery>(
 }

 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery>(
-	[v0,v1]:Simplex<2,M::Vert>,
-	mesh:&M,
+fn reduce2(
+	[v0,v1]:Simplex<2>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
+	let p0=-mesh.vert(v0);
+	let p1=-mesh.vert(v1);

 	// local p = -a
 	// local u = b - a
@@ -196,7 +161,7 @@ fn reduce2<M:MeshQuery>(
 		// -- modify the direction to take into account a0R and b0R
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -217,18 +182,18 @@ fn reduce2<M:MeshQuery>(
 }

 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery>(
-	[v0,mut v1,v2]:Simplex<3,M::Vert>,
-	mesh:&M,
+fn reduce3(
+	[v0,mut v1,v2]:Simplex<3>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced{
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	// local c = c1 - c0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
-	let p2=mesh.vert(v2);
+	let p0=-mesh.vert(v0);
+	let p1=-mesh.vert(v1);
+	let p2=-mesh.vert(v2);

 	// local p = -a
 	// local u = b - a
@@ -262,7 +227,7 @@ fn reduce3<M:MeshQuery>(

 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
-			dir:narrow_dir2(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 		};
 	}
@@ -296,14 +261,14 @@ fn reduce3<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uv
 			return Reduced{
-				dir:narrow_dir2(uv),
+				dir:uv.narrow_1().unwrap(),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}

 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -314,7 +279,7 @@ fn reduce3<M:MeshQuery>(
 	if dir==vec3::zero(){
 		// direction = uv
 		return Reduced{
-			dir:narrow_dir2(uv),
+			dir:uv.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex1([v0]),
 		};
 	}
@@ -326,20 +291,20 @@ fn reduce3<M:MeshQuery>(
 }

 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<M:MeshQuery>(
-	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
-	mesh:&M,
+fn reduce4(
+	[v0,mut v1,mut v2,v3]:Simplex<4>,
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-)->Reduce<M::Vert>{
+)->Reduce{
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
 	// local c = c1 - c0
 	// local d = d1 - d0
-	let p0=mesh.vert(v0);
-	let p1=mesh.vert(v1);
-	let p2=mesh.vert(v2);
-	let p3=mesh.vert(v3);
+	let p0=-mesh.vert(v0);
+	let p1=-mesh.vert(v1);
+	let p2=-mesh.vert(v2);
+	let p3=-mesh.vert(v3);

 	// local p = -a
 	// local u = b - a
@@ -367,8 +332,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 +361,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 +375,8 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}

@@ -424,15 +393,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:uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:-uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}
 	}

 	// local u_u = u:Dot(u)
@@ -464,20 +435,22 @@ 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:uv.narrow_1().unwrap(),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
 			}else{
-				narrow_dir2(-uv)
-			};
-			return Reduce::Reduced(Reduced{
-				dir,
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			});
+				return Reduce::Reduced(Reduced{
+					dir:-uv.narrow_1().unwrap(),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
 		}

 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
-			dir:narrow_dir3(direction),
+			dir:direction.narrow_1().unwrap(),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		});
 	}
@@ -487,15 +460,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:uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex1([v0]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:-uv.narrow_1().unwrap(),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
 	}

 	// return direction, a0, a1
@@ -505,18 +480,18 @@ fn reduce4<M:MeshQuery>(
 	})
 }

-struct Reduced<Vert>{
+struct Reduced{
 	dir:Planar64Vec3,
-	simplex:Simplex1_3<Vert>,
+	simplex:Simplex1_3,
 }

-enum Reduce<Vert>{
-	Escape(Simplex<4,Vert>),
-	Reduced(Reduced<Vert>),
+enum Reduce{
+	Escape(Simplex<4>),
+	Reduced(Reduced),
 }

-impl<Vert> Simplex2_4<Vert>{
-	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
+impl Simplex2_4{
+	fn reduce(self,mesh:&MinkowskiMesh,point:Planar64Vec3)->Reduce{
 		match self{
 			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
 			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
@@ -525,252 +500,57 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }

-//infinity fev algorithm state transition
-#[derive(Debug)]
-enum Transition<Vert>{
-	Done,//found closest vert, no edges are better
-	Vert(Vert),//transition to vert
+// local function expand(
+// 	queryP, queryQ,
+// 	vertA0, vertA1,
+// 	vertB0, vertB1,
+// 	vertC0, vertC1,
+// 	vertD0, vertD1,
+// 	accuracy
+// )
+fn refine_to_exact(mesh:&MinkowskiMesh,simplex:Simplex<4>)->Simplex2_4{
+	unimplemented!()
 }
-enum EV<M:MeshQuery>{
-	Vert(M::Vert),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+
+/// Intermediate data structure containing a partially complete calculation.
+/// Sometimes you only care about the topology, and not about the
+/// exact point of intersection details.
+pub struct Topology{
+	simplex:Simplex2_4,
 }
-impl<M:MeshQuery> From<EV<M>> for FEV<M>{
-	fn from(value:EV<M>)->Self{
-		match value{
-			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
-			EV::Edge(minkowski_edge)=>FEV::Edge(minkowski_edge),
-		}
+impl Topology{
+	/// Returns None if the point is intersecting the mesh.
+	pub fn closest_point_details(self,mesh:&MinkowskiMesh)->Option<Details>{
+		// NOTE: if hits is true, this if statement necessarily evaluates to true.
+		// i.e. hits implies this statement
+		// if -dist <= exitRadius + radiusP + radiusQ then
+		// 	local posP, posQ = decompose(-point, a0, a1, b0, b1, c0, c1)
+		// 	return hits, -dist - radiusP - radiusQ,
+		// 		posP - radiusP*norm, -norm,
+		// 		posQ + radiusQ*norm, norm
+		// end
+		// return false
+		unimplemented!()
 	}
 }
-
-trait Contains{
-	fn contains(&self,point:Planar64Vec3)->bool;
+pub struct Details{
+	// distance:Planar64,
+	// p_pos:Planar64Vec3,
+	// p_norm:Planar64Vec3,
+	// q_pos:Planar64Vec3,
+	// q_norm:Planar64Vec3,
 }

-// convenience type to check if a point is within some threshold of a plane.
-struct ThickPlane{
-	point:Planar64Vec3,
-	normal:Vector3<Fixed<2,64>>,
-	epsilon:Fixed<3,96>,
-}
-impl ThickPlane{
-	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
-		let p0=mesh.vert(v0);
-		let p1=mesh.vert(v1);
-		let p2=mesh.vert(v2);
-		let point=p0;
-		let normal=(p1-p0).cross(p2-p0);
-		// Allow ~ 2*sqrt(3) units of thickness on the plane
-		// This is to account for the variance of two voxels across the longest diagonal
-		let epsilon=(normal.length()*(Planar64::EPSILON*3)).wrap_3();
-		Self{point,normal,epsilon}
-	}
-}
-impl Contains for ThickPlane{
-	fn contains(&self,point:Planar64Vec3)->bool{
-		(point-self.point).dot(self.normal).abs()<=self.epsilon
-	}
-}
-
-struct ThickLine{
-	point:Planar64Vec3,
-	dir:Planar64Vec3,
-	epsilon:Fixed<4,128>,
-}
-impl ThickLine{
-	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
-		let p0=mesh.vert(v0);
-		let p1=mesh.vert(v1);
-		let point=p0;
-		let dir=p1-p0;
-		// Allow ~ 2*sqrt(3) units of thickness on the plane
-		// This is to account for the variance of two voxels across the longest diagonal
-		let epsilon=(dir.length_squared()*(Planar64::EPSILON*3)).widen_4();
-		Self{point,dir,epsilon}
-	}
-}
-impl Contains for ThickLine{
-	fn contains(&self,point:Planar64Vec3)->bool{
-		(point-self.point).cross(self.dir).length_squared()<=self.epsilon
-	}
-}
-
-struct EVFinder<'a,M,C>{
-	mesh:&'a M,
-	constraint:C,
-	best_distance_squared:Fixed<2,64>,
-}
-
-impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
-	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
-		let mut best_transition=Transition::Done;
-		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
-			//test if this edge's opposite vertex closer
-			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
-			//select opposite vertex
-			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
-			let test_pos=self.mesh.vert(test_vert_id);
-			let diff=point-test_pos;
-			let distance_squared=diff.dot(diff);
-			// ensure test_vert_id is coplanar to simplex
-			if distance_squared<self.best_distance_squared&&self.constraint.contains(test_pos){
-				best_transition=Transition::Vert(test_vert_id);
-				self.best_distance_squared=distance_squared;
-			}
-		}
-		best_transition
-	}
-	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
-		let mut best_transition=EV::Vert(vert_id);
-		let vert_pos=self.mesh.vert(vert_id);
-		let diff=point-vert_pos;
-		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
-			//test if this edge is closer
-			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
-			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
-			let test_pos=self.mesh.vert(test_vert_id);
-			let edge_n=test_pos-vert_pos;
-			let d=edge_n.dot(diff);
-			//test the edge
-			let edge_nn=edge_n.dot(edge_n);
-			// ensure edge contains closest point and directed_edge_id is coplanar to simplex
-			if !d.is_negative()&&d<=edge_nn&&self.constraint.contains(test_pos){
-				let distance_squared={
-					let c=diff.cross(edge_n);
-					//wrap for speed
-					(c.dot(c)/edge_nn).divide().wrap_2()
-				};
-				if distance_squared<=self.best_distance_squared{
-					best_transition=EV::Edge(directed_edge_id.as_undirected());
-					self.best_distance_squared=distance_squared;
-				}
-			}
-		}
-		best_transition
-	}
-	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
-		loop{
-			match self.next_transition_vert(vert_id,point){
-				Transition::Done=>return self.final_ev(vert_id,point),
-				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
-			}
-		}
-	}
-}
-/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
-	// naively start at the closest vertex
-	// the closest vertex is not necessarily the one with the fewest boundary hops
-	// but it doesn't matter, we will get there regardless.
-	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
-		let diff=point-mesh.vert(vert_id);
-		(vert_id,diff.dot(diff))
-	}).min_by_key(|&(_,d)|d).unwrap();
-
-	let constraint=ThickLine::new(mesh,simplex);
-	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
-	//start on any vertex
-	//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
-	//cross edge-face boundary if it's uncrossable
-	finder.crawl_boundaries(vert_id,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
-	// but it doesn't matter, we will get there regardless.
-	let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
-		let diff=point-mesh.vert(vert_id);
-		(vert_id,diff.dot(diff))
-	}).min_by_key(|&(_,d)|d).unwrap();
-
-	let constraint=ThickPlane::new(mesh,simplex);
-	let mut finder=EVFinder{constraint,mesh,best_distance_squared};
-	//start on any vertex
-	//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
-	//cross edge-face boundary if it's uncrossable
-	match finder.crawl_boundaries(vert_id,point){
-		//if a vert is returned, it is the closest point to the infinity point
-		EV::Vert(vert_id)=>FEV::Vert(vert_id),
-		EV::Edge(edge_id)=>{
-			//cross to face if we are on the wrong side
-			let edge_n=mesh.edge_n(edge_id);
-			// point is multiplied by two because vert_sum sums two vertices.
-			let delta_pos=point*2-{
-				let &[v0,v1]=mesh.edge_verts(edge_id).as_ref();
-				mesh.vert(v0)+mesh.vert(v1)
-			};
-			for (i,&face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
-				//test if this face is closer
-				let (face_n,d)=mesh.face_nd(face_id);
-				//if test point is behind face, the face is invalid
-				// TODO: find out why I thought of this backwards
-				if !(face_n.dot(point)-d).is_positive(){
-					continue;
-				}
-				//edge-face boundary nd, n facing out of the face towards the edge
-				let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
-				let boundary_d=boundary_n.dot(delta_pos);
-				//is test point behind edge, i.e. contained in the face
-				if !boundary_d.is_positive(){
-					//both faces cannot pass this condition, return early if one does.
-					return FEV::Face(face_id);
-				}
-			}
-			FEV::Edge(edge_id)
-		},
-	}
-}
-
-pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
-	const ENABLE_FAST_FAIL:bool=false;
-	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
-		// on_exact
-		|is_intersecting,simplex|{
-			if is_intersecting{
-				return None;
-			}
-			// Convert simplex to FEV
-			// Vertices must be inverted since the mesh is inverted
-			Some(match simplex{
-				Simplex1_3::Simplex1([v0])=>FEV::Vert(-v0),
-				Simplex1_3::Simplex2([v0,v1])=>{
-					// invert
-					let (v0,v1)=(-v0,-v1);
-					crawl_to_closest_ev(mesh,[v0,v1],point).into()
-				},
-				Simplex1_3::Simplex3([v0,v1,v2])=>{
-					// invert
-					let (v0,v1,v2)=(-v0,-v1,-v2);
-					// 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)
-				},
-			})
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
-			// let simplex=refine_to_exact(mesh,simplex);
-			None
-		},
-		// fast_fail value is irrelevant and will never be returned!
-		||unreachable!()
-	)
-}
-
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+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,
+	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
 		// on_exact
-		|is_intersecting,_simplex|{
-			is_intersecting
+		|last_pos,direction|{
+			// local norm = direction.unit
+			// local dist = a:Dot(norm)
+			// local hits = -dist < radiusP + radiusQ
+			// return hits
+			(last_pos+point).dot(direction).is_positive()
 		},
 		// on_escape
 		|_simplex|{
@@ -781,31 +561,46 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 		||false
 	)
 }
+pub fn closest_fev(mesh:&MinkowskiMesh,point:Planar64Vec3)->Topology{
+	const ENABLE_FAST_FAIL:bool=false;
+	minimum_difference::<ENABLE_FAST_FAIL,_>(mesh,point,
+		// on_exact
+		|_last_pos,_direction|unimplemented!(),
+		// on_escape
+		|simplex|{
+			// local norm, dist, u0, u1, v0, v1, w0, w1 = expand(queryP, queryQ, a0, a1, b0, b1, c0, c1, d0, d1, 1e-5)
+			let simplex=refine_to_exact(mesh,simplex);
+			Topology{simplex}
+		},
+		// fast_fail value is irrelevant and will never be returned!
+		||unreachable!()
+	)
+}

 // local function minimumDifference(
 // 	queryP, radiusP,
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
-	mesh:&M,
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
+	mesh:&MinkowskiMesh,
 	point:Planar64Vec3,
-	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
-	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
+	on_exact:impl FnOnce(Planar64Vec3,Planar64Vec3)->T,
+	on_escape:impl FnOnce(Simplex<4>)->T,
 	on_fast_fail:impl FnOnce()->T,
 )->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)
 	// local direction, a0, a1, b0, b1, c0, c1, d0, d1
-	let mut initial_axis=mesh.hint_point()+point;
+	let mut initial_axis=-mesh.hint_point()+point;
 	// degenerate case
 	if initial_axis==vec3::zero(){
 		initial_axis=choose_any_direction();
 	}
-	let last_point=mesh.farthest_vert(-initial_axis);
+	let last_point=mesh.farthest_vert(direction);
 	// this represents the 'a' value in the commented code
-	let mut last_pos=mesh.vert(last_point);
+	let mut last_pos=-mesh.vert(last_point);
 	let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);

 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
@@ -814,8 +609,8 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)
 		// local next_point = new_point_q - new_point_p
-		let next_point=mesh.farthest_vert(direction);
-		let next_pos=mesh.vert(next_point);
+		let next_point=mesh.farthest_vert(-direction);
+		let next_pos=-mesh.vert(next_point);

 		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
 		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
@@ -830,11 +625,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		if !direction.dot(next_pos-last_pos).is_positive()
 		||simplex_big.det_is_zero(mesh){
 			// Found enough information to compute the exact closest point.
-			// local norm = direction.unit
-			// local dist = a:Dot(norm)
-			// local hits = -dist < radiusP + radiusQ
-			let is_intersecting=(last_pos+point).dot(direction).is_positive();
-			return on_exact(is_intersecting,simplex_small);
+			return on_exact(last_pos,direction);
 		}

 		// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
@@ -855,41 +646,3 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		last_pos=next_pos;
 	}
 }
-
-#[cfg(test)]
-mod test{
-	use super::*;
-    use crate::model::{PhysicsMesh,PhysicsMeshView};
-
-    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
-		const ENABLE_FAST_FAIL:bool=true;
-		// TODO: remove mesh negation
-		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
-			// on_exact
-			|is_intersecting,_simplex|{
-				is_intersecting
-			},
-			// on_escape
-			|_simplex|{
-				// intersection is guaranteed at this point
-				true
-			},
-			// fast_fail value
-			||false
-		)
-	}
-
-	#[test]
-	fn test_cube_points(){
-		let mesh=PhysicsMesh::unit_cube();
-		let mesh_view=mesh.complete_mesh_view();
-		for x in -2..=2{
-			for y in -2..=2{
-				for z in -2..=2{
-					let point=vec3::int(x,y,z)>>1;
-					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
-				}
-			}
-		}
-	}
-}
--- a/engine/physics/src/minimum_difference_lua.rs
+++ b/engine/physics/src/minimum_difference_lua.rs
@@ -0,0 +1,159 @@
+use mlua::{Lua,FromLuaMulti,IntoLuaMulti,Function,Result as LuaResult,Vector};
+use strafesnet_common::integer::{Planar64,Planar64Vec3,FixedFromFloatError};
+
+use crate::model::{MeshQuery,MinkowskiMesh};
+
+pub fn contains_point(
+	mesh:&MinkowskiMesh,
+	point:Planar64Vec3,
+)->LuaResult<bool>{
+	Ok(minimum_difference(mesh,point,true)?.hits)
+}
+pub fn minimum_difference_details(
+	mesh:&MinkowskiMesh,
+	point:Planar64Vec3,
+)->LuaResult<(bool,Details)>{
+	let md=minimum_difference(mesh,point,false)?;
+	Ok((md.hits,md.details.unwrap()))
+}
+fn p64v3(v:Vector)->Result<Planar64Vec3,FixedFromFloatError>{
+	Ok(Planar64Vec3::new([
+		v.x().try_into()?,
+		v.y().try_into()?,
+		v.z().try_into()?,
+	]))
+}
+fn vec(v:Planar64Vec3)->Vector{
+	Vector::new(v.x.into(),v.y.into(),v.z.into())
+}
+struct MinimumDifference{
+	hits:bool,
+	details:Option<Details>
+}
+pub struct Details{
+	pub distance:Planar64,
+	pub p_pos:Planar64Vec3,
+	pub p_norm:Planar64Vec3,
+	pub q_pos:Planar64Vec3,
+	pub q_norm:Planar64Vec3,
+}
+impl FromLuaMulti for MinimumDifference{
+	fn from_lua_multi(mut values:mlua::MultiValue,_lua:&Lua)->LuaResult<Self>{
+		match values.make_contiguous(){
+			&mut [
+				mlua::Value::Boolean(hits),
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+				mlua::Value::Nil,
+			]=>Ok(Self{hits,details:None}),
+			&mut [
+				mlua::Value::Boolean(hits),
+				mlua::Value::Number(distance),
+				mlua::Value::Vector(p_pos),
+				mlua::Value::Vector(p_norm),
+				mlua::Value::Vector(q_pos),
+				mlua::Value::Vector(q_norm),
+			]=>Ok(Self{
+				hits,
+				details:Some(Details{
+					distance:distance.try_into().unwrap(),
+					p_pos:p64v3(p_pos).unwrap(),
+					p_norm:p64v3(p_norm).unwrap(),
+					q_pos:p64v3(q_pos).unwrap(),
+					q_norm:p64v3(q_norm).unwrap(),
+				}),
+			}),
+			values=>Err(mlua::Error::runtime(format!("Invalid return values: {values:?}"))),
+		}
+	}
+}
+
+struct Args{
+	query_p:Function,
+	radius_p:f64,
+	query_q:Function,
+	radius_q:f64,
+	exit_radius:f64,
+	test_intersection:bool,
+}
+impl Args{
+	fn new(
+		lua:&Lua,
+		mesh:&'static MinkowskiMesh<'static>,
+		point:Planar64Vec3,
+		test_intersection:bool,
+	)->LuaResult<Self>{
+		let radius_p=0.0;
+		let radius_q=0.0;
+		let exit_radius=0.0;
+		// Query the farthest point on the mesh in the given direction.
+		let query_p=lua.create_function(move|_,dir:Option<Vector>|{
+			let Some(dir)=dir else{
+				return Ok(vec(mesh.mesh0.hint_point()));
+			};
+			let dir=p64v3(dir).unwrap();
+			let vert_id=mesh.mesh0.farthest_vert(dir);
+			let dir=mesh.mesh0.vert(vert_id);
+			Ok(vec(dir))
+		})?;
+		// query_q is different since it includes the test point offset.
+		let query_q=lua.create_function(move|_,dir:Option<Vector>|{
+			let Some(dir)=dir else{
+				return Ok(vec(mesh.mesh1.hint_point()+point));
+			};
+			let dir=p64v3(dir).unwrap();
+			let vert_id=mesh.mesh1.farthest_vert(dir);
+			let dir=mesh.mesh1.vert(vert_id)+point;
+			Ok(vec(dir))
+		})?;
+		Ok(Args{
+			query_p,
+			radius_p,
+			query_q,
+			radius_q,
+			exit_radius,
+			test_intersection,
+		})
+	}
+}
+impl IntoLuaMulti for Args{
+	fn into_lua_multi(self,lua:&Lua)->LuaResult<mlua::MultiValue>{
+		use mlua::IntoLua;
+		Ok(mlua::MultiValue::from_vec(vec![
+			self.query_p.into_lua(lua)?,
+			self.radius_p.into_lua(lua)?,
+			self.query_q.into_lua(lua)?,
+			self.radius_q.into_lua(lua)?,
+			self.exit_radius.into_lua(lua)?,
+			self.test_intersection.into_lua(lua)?,
+		]))
+	}
+}
+
+fn minimum_difference(
+	mesh:&MinkowskiMesh,
+	point:Planar64Vec3,
+	test_intersection:bool,
+)->LuaResult<MinimumDifference>{
+	let ctx=init_lua()?;
+	// SAFETY: mesh lifetime must outlive args usages
+	let mesh=unsafe{core::mem::transmute(mesh)};
+	let args=Args::new(&ctx.lua,mesh,point,test_intersection)?;
+	ctx.f.call(args)
+}
+
+struct Ctx{
+	lua:Lua,
+	f:Function,
+}
+fn init_lua()->LuaResult<Ctx>{
+	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("/home/quat/strafesnet/game/src/ReplicatedStorage/Shared/Trey-MinimumDifference.lua").unwrap());
+	let lua=Lua::new();
+	lua.sandbox(true)?;
+	let lib_f=lua.load(SOURCE.as_str()).set_name("Trey-MinimumDifference").into_function()?;
+	let lib:mlua::Table=lib_f.call(())?;
+	let f=lib.raw_get("difference")?;
+	Ok(Ctx{lua,f})
+}
--- a/engine/physics/src/model.rs
+++ b/engine/physics/src/model.rs
@@ -60,7 +60,7 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 }

 //Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug,Clone)]
+#[derive(Debug)]
 pub enum FEV<M:MeshQuery>{
 	Face(M::Face),
 	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
@@ -92,7 +92,6 @@ pub trait MeshQuery{
 	}
 	/// This must return a point inside the mesh.
 	fn hint_point(&self)->Planar64Vec3;
-	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
 	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
 	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
@@ -103,21 +102,17 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
-	// I didn't write it down, but I assume the edges are directed
-	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
-	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//start, end
+	verts:[SubmeshVertId;2],//bottom, top
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
-	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -439,29 +434,11 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }

-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
 }
-impl PhysicsMeshView<'_>{
-	pub fn verts(&self)->&[MeshVertId]{
-		&self.topology.verts
-	}
-	pub fn edge_vert_ids_iter(&self)->impl Iterator<Item=[MeshVertId;2]>+'_{
-		self.topology.edge_topology.iter().map(|edge|{
-			edge.verts.map(|vert_id|self.topology.verts[vert_id.get() as usize])
-		})
-	}
-	pub fn face_vert_ids_iter(&self)->impl Iterator<Item=impl Iterator<Item=MeshVertId>>+'_{
-		self.topology.face_topology.iter().map(|face|{
-			face.edges.iter().map(|edge_id|{
-				let vert_id=self.topology.edge_topology[edge_id.as_undirected().get() as usize].verts[edge_id.parity() as usize];
-				self.topology.verts[vert_id.get() as usize]
-			})
-		})
-	}
-}
 impl MeshQuery for PhysicsMeshView<'_>{
 	type Face=SubmeshFaceId;
 	type Edge=SubmeshDirectedEdgeId;
@@ -476,18 +453,6 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		// invariant: meshes always encompass the origin
 		vec3::zero()
 	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
-		//this happens to be well-defined.  there are no virtual virtices
-		SubmeshVertId::new(
-			self.topology.verts.iter()
-			.enumerate()
-			.max_by_key(|&(_,&vert_id)|
-				dir.dot(self.data.verts[vert_id.get() as usize].0)
-			)
-			//assume there is more than zero vertices.
-			.unwrap().0 as u32
-		)
-	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
@@ -526,7 +491,7 @@ impl PhysicsMeshTransform{
 	}
 }

-#[derive(Debug,Clone,Copy)]
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -544,8 +509,17 @@ 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)
+	pub fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
+		//this happens to be well-defined.  there are no virtual virtices
+		SubmeshVertId::new(
+			self.view.topology.verts.iter()
+			.enumerate()
+			.max_by_key(|&(_,&vert_id)|
+				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
+			)
+			//assume there is more than zero vertices.
+			.unwrap().0 as u32
+		)
 	}
 }
 impl MeshQuery for TransformedMesh<'_>{
@@ -567,18 +541,6 @@ impl MeshQuery for TransformedMesh<'_>{
 	fn hint_point(&self)->Planar64Vec3{
 		self.transform.vertex.translation
 	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
-		//this happens to be well-defined.  there are no virtual virtices
-		SubmeshVertId::new(
-			self.view.topology.verts.iter()
-			.enumerate()
-			.max_by_key(|&(_,&vert_id)|
-				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
-			)
-			//assume there is more than zero vertices.
-			.unwrap().0 as u32
-		)
-	}
 	#[inline]
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
@@ -609,15 +571,6 @@ impl MeshQuery for TransformedMesh<'_>{
 pub enum MinkowskiVert{
 	VertVert(SubmeshVertId,SubmeshVertId),
 }
-// TODO: remove this
-impl core::ops::Neg for MinkowskiVert{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		match self{
-			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
-		}
-	}
-}
 #[derive(Clone,Copy,Debug)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
@@ -654,7 +607,7 @@ impl DirectedEdge for MinkowskiDirectedEdge{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug,Hash)]
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 pub enum MinkowskiFace{
 	VertFace(SubmeshVertId,SubmeshFaceId),
 	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
@@ -666,33 +619,19 @@ pub enum MinkowskiFace{

 #[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
+	pub mesh0:TransformedMesh<'a>,
+	pub mesh1:TransformedMesh<'a>,
 }

-impl FEV<MinkowskiMesh<'_>>{
-	pub fn mesh0<'a>(self)->FEV<TransformedMesh<'a>>{
-		match self{
-			FEV::Face(face)=>{
-				match face{
-					MinkowskiFace::VertFace(submesh_vert_id,_)=>FEV::Vert(submesh_vert_id),
-					MinkowskiFace::EdgeEdge(submesh_edge_id,..)=>FEV::Edge(submesh_edge_id),
-					MinkowskiFace::FaceVert(submesh_face_id,_)=>FEV::Face(submesh_face_id),
-				}
-			},
-			FEV::Edge(edge)=>{
-				match edge{
-					MinkowskiEdge::VertEdge(submesh_vert_id,_)=>FEV::Vert(submesh_vert_id),
-					MinkowskiEdge::EdgeVert(submesh_edge_id,_)=>FEV::Edge(submesh_edge_id),
-				}
-			},
-			FEV::Vert(vert)=>{
-				match vert{
-					MinkowskiVert::VertVert(submesh_vert_id,_)=>FEV::Vert(submesh_vert_id),
-				}
-			},
-		}
-	}
+//infinity fev algorithm state transition
+#[derive(Debug)]
+enum Transition{
+	Done,//found closest vert, no edges are better
+	Vert(MinkowskiVert),//transition to vert
+}
+enum EV{
+	Vert(MinkowskiVert),
+	Edge(MinkowskiEdge),
 }

 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
@@ -701,14 +640,6 @@ pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }

-// TODO: remove this
-impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
-	type Output=MinkowskiMesh<'a>;
-	fn neg(self)->Self::Output{
-		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
-	}
-}
-
 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
 		MinkowskiMesh{
@@ -716,32 +647,140 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let start_position=match range.start_bound(){
-			Bound::Included(time)=>relative_body.extrapolated_position(*time),
-			Bound::Excluded(time)=>relative_body.extrapolated_position(*time),
-			Bound::Unbounded=>relative_body.position,
+	pub fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
+		let mut best_transition=Transition::Done;
+		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//is boundary uncrossable by a crawl from infinity
+			let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
+			//select opposite vertex
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
+			//test if it's closer
+			let diff=point-self.vert(test_vert_id);
+			if edge_n.dot(infinity_dir).is_zero(){
+				let distance_squared=diff.dot(diff);
+				if distance_squared<*best_distance_squared{
+					best_transition=Transition::Vert(test_vert_id);
+					*best_distance_squared=distance_squared;
+				}
+			}
+		}
+		best_transition
+	}
+	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
+		let mut best_transition=EV::Vert(vert_id);
+		let diff=point-self.vert(vert_id);
+		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//is boundary uncrossable by a crawl from infinity
+			//check if time of collision is outside Time::MIN..Time::MAX
+			if edge_n.dot(infinity_dir).is_zero(){
+				let d=edge_n.dot(diff);
+				//test the edge
+				let edge_nn=edge_n.dot(edge_n);
+				if !d.is_negative()&&d<=edge_nn{
+					let distance_squared={
+						let c=diff.cross(edge_n);
+						//wrap for speed
+						(c.dot(c)/edge_nn).divide().wrap_2()
+					};
+					if distance_squared<=*best_distance_squared{
+						best_transition=EV::Edge(directed_edge_id.as_undirected());
+						*best_distance_squared=distance_squared;
+					}
+				}
+			}
+		}
+		best_transition
+	}
+	fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
+		let mut best_distance_squared={
+			let diff=point-self.vert(vert_id);
+			diff.dot(diff)
 		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		//continue forwards along the body parabola
-		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		loop{
+			match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
+				Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
+				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
+			}
+		}
+	}
+	/// 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 infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh<'_>>{
+		//start on any vertex
+		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
+		//cross edge-face boundary if it's uncrossable
+		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
+			//if a vert is returned, it is the closest point to the infinity point
+			EV::Vert(vert_id)=>FEV::Vert(vert_id),
+			EV::Edge(edge_id)=>{
+				//cross to face if the boundary is not crossable and we are on the wrong side
+				let edge_n=self.edge_n(edge_id);
+				// point is multiplied by two because vert_sum sums two vertices.
+				let delta_pos=point*2-{
+					let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+					self.vert(v0)+self.vert(v1)
+				};
+				for (i,&face_id) in self.edge_faces(edge_id).as_ref().iter().enumerate(){
+					let face_n=self.face_nd(face_id).0;
+					//edge-face boundary nd, n facing out of the face towards the edge
+					let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
+					let boundary_d=boundary_n.dot(delta_pos);
+					//check if time of collision is outside Time::MIN..Time::MAX
+					//infinity_dir can always be treated as a velocity
+					if !boundary_d.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
+						//both faces cannot pass this condition, return early if one does.
+						return FEV::Face(face_id);
+					}
+				}
+				FEV::Edge(edge_id)
+			},
+		}
+	}
+	// TODO: fundamentally improve this algorithm.
+	// All it needs to do is find the closest point on the mesh
+	// and return the FEV which the point resides on.
+	//
+	// What it actually does is use the above functions to trace a ray in from infinity,
+	// crawling the closest point along the mesh surface until the ray reaches
+	// the starting point to discover the final FEV.
+	//
+	// The actual collision prediction probably does a single test
+	// and then immediately returns with 0 FEV transitions on average,
+	// because of the strict time_limit constraint.
+	//
+	// Most of the calculation time is just calculating the starting point
+	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
+	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh<'_>>>{
+		infinity_body.infinity_dir().and_then(|dir|{
+			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
+			//a line is simpler to solve than a parabola
+			infinity_body.velocity=dir;
+			infinity_body.acceleration=vec3::zero();
+			//crawl in from negative infinity along a tangent line to get the closest fev
+			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
+		})
+	}
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
+			//continue forwards along the body parabola
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+		})
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		let (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)=>relative_body.extrapolated_position(*time),
-			Bound::Excluded(time)=>relative_body.extrapolated_position(*time),
-			Bound::Unbounded=>relative_body.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
 		let infinity_body=-relative_body;
-		//continue backwards along the body parabola
-		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time))
+		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
+			//continue backwards along the body parabola
+			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+				//no need to test -time<time_limit because of the first step
+				.map(|(face,time)|(face,-time))
+		})
 	}
 	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
 		// TODO: make better
@@ -772,7 +811,10 @@ impl MinkowskiMesh<'_>{
 		best_edge
 	}
 	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		crate::minimum_difference::contains_point(self,point)
+		let contains_point_lua=crate::minimum_difference_lua::contains_point(self,point).unwrap();
+		let contains_point=crate::minimum_difference::contains_point(self,point);
+		println!("contains_point={contains_point} contains_point_lua={contains_point_lua}");
+		contains_point
 	}
 }
 impl MeshQuery for MinkowskiMesh<'_>{
@@ -814,9 +856,6 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	fn hint_point(&self)->Planar64Vec3{
 		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
 	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
-	}
 	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
--- a/engine/physics/src/physics.rs
+++ b/engine/physics/src/physics.rs
@@ -1,5 +1,4 @@
 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;
@@ -29,7 +28,6 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
-	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -288,8 +286,7 @@ impl PhysicsCamera{
 		.clamp(Self::ANGLE_PITCH_LOWER_LIMIT,Self::ANGLE_PITCH_UPPER_LIMIT);
 		mat3::from_rotation_yx(ax,ay)
 	}
-	#[inline]
-	pub fn rotation(&self)->Planar64Mat3{
+	fn rotation(&self)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos)
 	}
 	#[expect(dead_code)]
@@ -671,7 +668,7 @@ impl From<CollisionAttributesId> for IntersectAttributesId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct ContactModelId(u32);
+struct ContactModelId(u32);
 impl From<ContactModelId> for ModelId{
 	fn from(value:ContactModelId)->ModelId{
 		ModelId::new(value.get())
@@ -683,7 +680,7 @@ impl From<ModelId> for ContactModelId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-pub struct IntersectModelId(u32);
+struct IntersectModelId(u32);
 impl From<IntersectModelId> for ModelId{
 	fn from(value:IntersectModelId)->ModelId{
 		ModelId::new(value.get())
@@ -695,7 +692,7 @@ impl From<ModelId> for IntersectModelId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-pub enum PhysicsModelId{
+enum PhysicsModelId{
 	Contact(ContactModelId),
 	Intersect(IntersectModelId),
 }
@@ -709,9 +706,9 @@ impl From<PhysicsModelId> for ModelId{
 }
 //unique physics meshes indexed by this
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
-pub struct ConvexMeshId<Id>{
-	pub model_id:Id,
-	pub submesh_id:PhysicsSubmeshId,
+struct ConvexMeshId<Id>{
+	model_id:Id,
+	submesh_id:PhysicsSubmeshId,
 }
 impl<Id> ConvexMeshId<Id>{
 	fn map<NewId>(self,model_id:NewId)->ConvexMeshId<NewId>{
@@ -732,7 +729,7 @@ struct IntersectModel{
 	transform:PhysicsMeshTransform,
 }

-#[derive(Debug,Clone,Copy,Hash)]
+#[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
@@ -741,7 +738,7 @@ pub struct ContactCollision{
 pub struct IntersectCollision{
 	convex_mesh_id:ConvexMeshId<IntersectModelId>,
 }
-#[derive(Debug,Clone,Hash)]
+#[derive(Debug,Clone,Eq,Hash,PartialEq)]
 pub enum Collision{
 	Contact(ContactCollision),
 	Intersect(IntersectCollision),
@@ -1000,57 +997,6 @@ impl PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
-	pub fn trace_ray(&self,ray:strafesnet_common::ray::Ray)->Option<ConvexMeshId<PhysicsModelId>>{
-		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)
-	}
-	pub fn closest_fev_not_inside(&self,convex_mesh_id:ConvexMeshId<PhysicsModelId>,point:Planar64Vec3)->Option<model_physics::FEV<model_physics::MinkowskiMesh<'_>>>{
-		let model_mesh=self.models.mesh(convex_mesh_id);
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,self.hitbox_mesh.transformed_mesh());
-		let fev=crate::minimum_difference::closest_fev_not_inside(&minkowski,point)?;
-		Some(fev)
-	}
-	pub fn trace(&self,convex_mesh_id:ConvexMeshId<PhysicsModelId>,body:&Body,time:Time)->Option<model_physics::FEV<model_physics::MinkowskiMesh<'_>>>{
-		let model_mesh=self.models.mesh(convex_mesh_id);
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,self.hitbox_mesh.transformed_mesh());
-		let fev=crate::minimum_difference::closest_fev_not_inside(&minkowski,body.extrapolated_position(time))?;
-		Some(fev)
-	}
 	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
@@ -1199,9 +1145,6 @@ impl PhysicsData{
 			modes,
 		}
 	}
-	pub fn vertex_transform(&self)->&integer::Planar64Affine3{
-		&self.hitbox_mesh.transform.vertex
-	}
 }
 // the collection of information required to run physics
 pub struct PhysicsContext<'a>{
@@ -1726,20 +1669,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:?}"),
 				}
 			},
@@ -1813,14 +1743,17 @@ 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.advance_time_ratio_dt(dt),
-		// this advances imprecisely
-		InternalInstruction::ReachWalkTargetVelocity=>state.body.advance_time(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,_)=>{
@@ -1867,8 +1800,6 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						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
-							state.body.advance_time(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(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
@@ -2041,7 +1972,7 @@ 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_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -2059,7 +1990,7 @@ 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:Body,expected_collision_time:Option<Time>){
--- a/engine/session/src/session.rs
+++ b/engine/session/src/session.rs
@@ -48,11 +48,11 @@ pub enum SessionControlInstruction{
 	StopSpectate,
 	SaveReplay,
 	LoadIntoReplayState,
-	DebugSimulation,
 }
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
+	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
@@ -61,8 +61,6 @@ pub struct FrameState{
 	pub body:physics::Body,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
-	pub hit:Option<Hit>,
-	pub debug_hitbox_position:Option<strafesnet_common::integer::Planar64Affine3>,
 }

 pub struct Simulation{
@@ -79,38 +77,11 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(
-		&self,
-		time:SessionTime,
-		debug_model:Option<Hit>,
-		debug_hitbox_position:Option<strafesnet_common::integer::Planar64Affine3>,
-	)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
 		FrameState{
 			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
-			hit:debug_model,
-			debug_hitbox_position,
-		}
-	}
-}
-
-// a paused simulation which displays a period of its future traced over the model under the cursor
-struct DebugSimulation{
-	physics:physics::PhysicsState,
-	timer:strafesnet_common::timer::TimerFixed<Scaled<SessionTimeInner,PhysicsTimeInner>,strafesnet_common::timer::Paused>,
-	cycle_duration:PhysicsTime,
-}
-impl DebugSimulation{
-	pub fn new(simulation:&Simulation,time:SessionTime,cycle_duration:PhysicsTime)->Self{
-		let timer=match &simulation.timer{
-			Timer::Paused(timer_fixed)=>*timer_fixed,
-			Timer::Unpaused(timer_fixed)=>timer_fixed.into_paused(time),
-		};
-		Self{
-			physics:simulation.physics.clone(),
-			timer,
-			cycle_duration,
 		}
 	}
 }
@@ -178,12 +149,6 @@ enum ViewState{
 	Replay(BotId),
 }

-#[derive(Clone)]
-pub struct Hit{
-	pub convex_mesh_id:physics::ConvexMeshId<physics::PhysicsModelId>,
-	pub closest_fev:Option<strafesnet_physics::model::FEV<strafesnet_physics::model::TransformedMesh<'static>>>
-}
-
 pub struct Session{
 	directories:Directories,
 	user_settings:UserSettings,
@@ -196,8 +161,6 @@ pub struct Session{
 	recording:Recording,
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
-	last_ray_hit:Option<Hit>,
-	debug_simulation:Option<DebugSimulation>,
 }
 impl Session{
 	pub fn new(
@@ -214,8 +177,6 @@ impl Session{
 			view_state:ViewState::Play,
 			recording:Default::default(),
 			replays:HashMap::new(),
-			last_ray_hit:None,
-			debug_simulation:None,
 		}
 	}
 	fn clear_recording(&mut self){
@@ -226,45 +187,13 @@ impl Session{
 		self.geometry_shared=PhysicsData::new(map);
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
-		let debug_hitbox_position=self.debug_simulation.as_ref().map(|debug_simulation|{
-			let simulation_time=debug_simulation.timer.time();
-			let loop_time=simulation_time+PhysicsTime::raw(time.get().rem_euclid(debug_simulation.cycle_duration.get())>>1);
-			let transform=self.geometry_shared.vertex_transform();
-			strafesnet_common::integer::Planar64Affine3::new(transform.matrix3,debug_simulation.physics.body().extrapolated_position(loop_time))
-		});
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time,self.last_ray_hit.clone(),debug_hitbox_position)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time,None,debug_hitbox_position)
+				replay.simulation.get_frame_state(time)
 			),
 		}
 	}
-	pub fn debug_raycast_print_model_id_if_changed(&mut self,time:SessionTime){
-		let Some(debug_simulation)=&self.debug_simulation else{
-			return;
-		};
-		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,
-			};
-			match self.geometry_shared.trace_ray(ray){
-				Some(convex_mesh_id)=>{
-					if self.last_ray_hit.as_ref().map_or(true,|last|last.convex_mesh_id!=convex_mesh_id){
-						println!("MeshId={convex_mesh_id:?}");
-					}
-					let simulation_time=debug_simulation.timer.time();
-					let loop_time=simulation_time+PhysicsTime::raw(time.get().rem_euclid(debug_simulation.cycle_duration.get())>>1);
-					let closest_fev=self.geometry_shared.trace(convex_mesh_id,debug_simulation.physics.body(),loop_time);
-					self.last_ray_hit=Some(Hit{
-						convex_mesh_id,
-						closest_fev:closest_fev.map(|fev|fev.mesh0()),
-					});
-				},
-				None=>self.last_ray_hit=None,
-			}
-		}
-	}
 	pub fn user_settings(&self)->&UserSettings{
 		&self.user_settings
 	}
@@ -324,14 +253,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// don't flush the buffered instructions in the mouse interpolator
 				// until the mouse is confirmed to be not moving at a later time
 				// what if they pause for 5ms lmao
-				match &self.view_state{
-					ViewState::Play=>{
-						_=self.simulation.timer.set_paused(ins.time,paused);
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,paused);
-					},
-				}
+				_=self.simulation.timer.set_paused(ins.time,paused);
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -452,6 +374,14 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 					},
 				}
 			},
+			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
+					},
+				}
+			}
 			Instruction::ChangeMap(complete_map)=>{
 				self.clear_recording();
 				self.change_map(complete_map);
@@ -480,10 +410,6 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// begin spectate
 				self.view_state=ViewState::Replay(bot_id);
 			},
-			Instruction::Control(SessionControlInstruction::DebugSimulation)=>{
-				println!("Body={}",self.simulation.physics.body());
-				self.debug_simulation=Some(DebugSimulation::new(&self.simulation,ins.time,PhysicsTime::ONE_SECOND<<1));
-			},
 			Instruction::Idle=>{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Idle);
 				// this just refreshes the replays
--- a/integration-testing/src/tests.rs
+++ b/integration-testing/src/tests.rs
@@ -60,12 +60,8 @@ 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,
 	);
--- a/lib/fixed_wide/src/fixed.rs
+++ b/lib/fixed_wide/src/fixed.rs
@@ -366,7 +366,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.

 // This macro is not used in the default configuration.
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );

 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication

-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
--- a/lib/rbx_loader/Cargo.toml
+++ b/lib/rbx_loader/Cargo.toml
@@ -12,17 +12,17 @@ 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_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
 rbx_mesh = "0.5.0"
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
-rbx_binary = "2.0.1"
-rbx_dom_weak = "4.1.0"
-rbx_reflection = "6.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_xml = "2.0.1"

 [lints]
 workspace = true
--- a/lib/rbx_loader/src/rbx.rs
+++ b/lib/rbx_loader/src/rbx.rs
@@ -559,7 +559,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);

-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|
--- a/lib/roblox_emulator/Cargo.toml
+++ b/lib/roblox_emulator/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.2"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,10 @@ run-service=[]
 glam = "0.30.0"
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
-rbx_dom_weak = "4.1.0"
-rbx_reflection = "6.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_types = "3.1.0"
+rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_types = "2.0.0"

 [lints]
 workspace = true
--- a/lib/roblox_emulator/src/context.rs
+++ b/lib/roblox_emulator/src/context.rs
@@ -52,7 +52,7 @@ impl Context{
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get().unwrap();
+		let db=rbx_reflection_database::get();
 		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};
--- a/lib/roblox_emulator/src/runner/enum.rs
+++ b/lib/roblox_emulator/src/runner/enum.rs
@@ -37,7 +37,7 @@ impl PartialEq for EnumItem<'_>{
 pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get().unwrap();
+		let db=rbx_reflection_database::get();
 		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }
--- a/lib/roblox_emulator/src/runner/instance/instance.rs
+++ b/lib/roblox_emulator/src/runner/instance/instance.rs
@@ -37,7 +37,7 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>
 }

 pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
@@ -80,14 +80,14 @@ pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak
 }

 pub fn find_first_child_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
 pub fn find_first_descendant_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
@@ -282,7 +282,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
-				let db=rbx_reflection_database::get().unwrap();
+				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
@@ -344,7 +344,7 @@ impl mlua::UserData for Instance{
 			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
-				let db=rbx_reflection_database::get().unwrap();
+				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)
--- a/map-tool/Cargo.toml
+++ b/map-tool/Cargo.toml
@@ -13,10 +13,10 @@ futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
-rbx_binary = "2.0.1"
-rbx_dom_weak = "4.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_xml = "2.0.1"
+rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
--- a/strafe-client/Cargo.toml
+++ b/strafe-client/Cargo.toml
@@ -28,7 +28,7 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "28.0.0"
+wgpu = "27.0.0"
 winit = "0.30.7"

 [profile.dev]
--- a/strafe-client/models/suzanne.obj
+++ b/strafe-client/models/suzanne.obj
--- a/strafe-client/models/teapot.obj
+++ b/strafe-client/models/teapot.obj
--- a/strafe-client/models/teslacyberv3.0.mtl
+++ b/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
--- a/strafe-client/models/teslacyberv3.0.obj
+++ b/strafe-client/models/teslacyberv3.0.obj
--- a/strafe-client/src/physics_worker.rs
+++ b/strafe-client/src/physics_worker.rs
@@ -59,10 +59,6 @@ pub fn new<'a>(
 			},
 			Instruction::Render=>{
 				run_session_instruction!(ins.time,SessionInstruction::Idle);
-
-				// update model under cursor
-				session.debug_raycast_print_model_id_if_changed(ins.time);
-
 				if let Some(frame_state)=session.get_frame_state(ins.time){
 					run_graphics_worker_instruction!(GraphicsInstruction::Render(frame_state));
 				}
--- a/strafe-client/src/setup.rs
+++ b/strafe-client/src/setup.rs
@@ -3,7 +3,7 @@ fn optional_features()->wgpu::Features{
 	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
 }
 fn required_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_BC|wgpu::Features::EXPERIMENTAL_MESH_SHADER
+	wgpu::Features::TEXTURE_COMPRESSION_BC
 }
 fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
 	wgpu::DownlevelCapabilities{
@@ -52,7 +52,7 @@ impl<'a> SetupContextPartial2<'a>{
 		let required_features=required_features();

 		//no helper function smh gotta write it myself
-		let adapters=pollster::block_on(self.instance.enumerate_adapters(self.backends));
+		let adapters=self.instance.enumerate_adapters(self.backends);

 		let mut chosen_adapter=None;
 		let mut chosen_adapter_score=0;
@@ -125,7 +125,7 @@ impl<'a> SetupContextPartial3<'a>{
 					required_limits:needed_limits,
 					memory_hints:wgpu::MemoryHints::Performance,
 					trace:wgpu::Trace::Off,
-					experimental_features:unsafe{wgpu::ExperimentalFeatures::enabled()},
+					experimental_features:wgpu::ExperimentalFeatures::disabled(),
 				},
 			))
 			.expect("Unable to find a suitable GPU adapter!");
--- a/strafe-client/src/shader.wgsl
+++ b/strafe-client/src/shader.wgsl
@@ -1,5 +1,3 @@
-enable wgpu_mesh_shader;
-
 struct Camera {
 	// from camera to screen
 	proj: mat4x4<f32>,
@@ -88,166 +86,6 @@ fn vs_entity_texture(
 	return result;
 }

-@group(1)
-@binding(0)
-var<uniform> model_instance: ModelInstance;
-
-@group(1)
-@binding(1)
-var<uniform> ve_verts: array<vec4<f32>, 2>;
-
-struct DebugEntityOutput {
-	@builtin(position) position: vec4<f32>,
-};
-
-@vertex
-fn vs_debug(
-	@location(0) pos: vec3<f32>,
-) -> DebugEntityOutput {
-	var position: vec4<f32> = model_instance.transform * vec4<f32>(pos, 1.0);
-	var result: DebugEntityOutput;
-	result.position = camera.proj * camera.view * position;
-	return result;
-}
-
-struct TaskPayload {
-    four_bytes: u32,
-}
-
-var<task_payload> taskPayload: TaskPayload;
-
-@task
-@payload(taskPayload)
-@workgroup_size(1)
-fn ts_main() -> @builtin(mesh_task_size) vec3<u32> {
-	taskPayload.four_bytes = 0;
-	return vec3(1, 1, 1);
-}
-
-struct VertexOutput {
-	@builtin(position) position: vec4<f32>,
-	@location(0) color: vec4<f32>,
-}
-struct PrimitiveOutput {
-	@builtin(triangle_indices) indices: vec3<u32>,
-}
-
-struct CircleOutput {
-	@builtin(vertices) vertices: array<VertexOutput, 24>,
-	@builtin(primitives) primitives: array<PrimitiveOutput, 22>,
-	@builtin(vertex_count) vertex_count: u32,
-	@builtin(primitive_count) primitive_count: u32,
-}
-
-var<workgroup> mesh_output: CircleOutput;
-
-const tau: f32 = 3.141592653589793 * 2.0;
-
-fn modulo(value:u32,modulus:u32)->u32{
-	return value-value/modulus*modulus;
-}
-
-@mesh(mesh_output)
-@payload(taskPayload)
-@workgroup_size(1)
-fn ms_debug_vert(){
-	// circle with 24 vertices.
-	const LAYERS:u32 = 3;
-	const N:u32 = 3*(1<<LAYERS);
-	mesh_output.vertex_count = N;
-	mesh_output.primitive_count = N-2;
-
-	var vertex_world_position: vec4<f32> = model_instance.transform * ve_verts[0];
-	var vertex_screen_position: vec4<f32> = camera.proj * camera.view * vertex_world_position;
-
-	for (var i:u32 = 0; i<N/4; i++){
-		// draw a 1 unit redius circle
-		var theta: f32 = f32(i) * tau / f32(N);
-		var cos_sin: vec2<f32> = vec2(cos(theta), sin(theta));
-		var offset: vec2<f32> = 0.5 * cos_sin;
-		mesh_output.vertices[i].position = vertex_screen_position + vec4<f32>(offset, 0.0, 0.0);
-		mesh_output.vertices[i+N/4].position = vertex_screen_position + vec4<f32>(-offset.y, offset.x, 0.0, 0.0);
-		mesh_output.vertices[i+N/4*2].position = vertex_screen_position + vec4<f32>(-offset, 0.0, 0.0);
-		mesh_output.vertices[i+N/4*3].position = vertex_screen_position + vec4<f32>(offset.y, -offset.x, 0.0, 0.0);
-	}
-
-	// max area triangle indices
-
-	// the big triangle
-	mesh_output.primitives[0].indices = vec3<u32>(0, N/3, N/3*2);
-
-	// 3 layers of infill triangles to approximate circle better than 1 triangle.
-	// we start on the outer layer because it's easier to construct this way
-	var count:u32=N;
-	var base:u32=1;
-	for (var layer:u32 = 0; layer<LAYERS; layer++){
-		count=count>>1;
-		var step:u32=N/count;
-		for (var i:u32 = 0; i<count; i++){
-			mesh_output.primitives[base+i].indices = vec3<u32>(i*step, i*step+(step>>1), modulo(i*step+step,N));
-		}
-		base+=count;
-	}
-}
-
-@mesh(mesh_output)
-@payload(taskPayload)
-@workgroup_size(1)
-fn ms_debug_edge(){
-	// draw two circles for now.
-	const LAYERS:u32 = 3;
-	const N:u32 = 2*(1<<LAYERS);
-	mesh_output.vertex_count = 2*(3+2+4+8);
-	mesh_output.primitive_count = 2*(1+2+4+8)+2;
-
-	var v0_world_position: vec4<f32> = model_instance.transform * ve_verts[0];
-	var v1_world_position: vec4<f32> = model_instance.transform * ve_verts[1];
-
-	var v0_screen_position: vec4<f32> = camera.proj * camera.view * v0_world_position;
-	var v1_screen_position: vec4<f32> = camera.proj * camera.view * v1_world_position;
-
-	var edge_dir_world: vec4<f32> = normalize(v0_world_position - v1_world_position);
-	var edge_dir_screen: vec4<f32> = camera.proj * camera.view * edge_dir_world;
-
-	for (var i:u32 = 0; i<=N/2; i++){
-		// two half circles that make a whole
-		var theta: f32 = f32(i) * tau / f32(N);
-		var cos_sin: vec2<f32> = vec2(cos(theta), sin(theta));
-
-		// construct basis vectors
-		var y_axis: vec2<f32> = edge_dir_screen.xy;
-		var x_axis: vec2<f32> = y_axis.yx;
-		x_axis.x = -x_axis.x;
-
-		var offset: vec4<f32> = vec4<f32>(0.5 * (x_axis * cos_sin.x + y_axis * cos_sin.y), 0.0, 0.0);;
-
-		mesh_output.vertices[i].position = v0_screen_position + offset;
-		mesh_output.vertices[N/2+1+i].position = v1_screen_position - offset;
-	}
-
-	// max area triangle indices
-	// number of primitives per circle half
-	const P:u32 = N/2;
-	// the big triangles between the circles
-	mesh_output.primitives[0].indices = vec3<u32>(0, N/2+1, P);
-	mesh_output.primitives[P].indices = vec3<u32>(N/2+1, 0, P + N/2+1);
-
-	// 3 layers of infill triangles to approximate circle better than 1 triangle.
-	// we start on the outer layer because it's easier to construct this way
-	var count:u32=P;
-	var base:u32=1;
-	for (var layer:u32 = 0; layer<LAYERS; layer++){
-		count=count>>1;
-		var step:u32=P/count;
-		for (var i:u32 = 0; i<count; i++){
-			var indices = vec3<u32>(i*step, i*step+(step>>1), i*step+step);
-			mesh_output.primitives[base+i].indices = indices;
-			mesh_output.primitives[P+base+i].indices = indices + N/2+1;
-		}
-		base+=count;
-	}
-}
-
 //group 2 is the skybox texture
@group(1)
@binding(0)
@@ -272,8 +110,3 @@ 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;
-}
--- a/strafe-client/src/window.rs
+++ b/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);
@@ -139,16 +132,7 @@ impl WindowContext<'_>{
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,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),
@@ -171,7 +155,6 @@ impl WindowContext<'_>{
 								"X"|"x"=>session_ctrl!(StopSpectate,s),
 								"N"|"n"=>session_ctrl!(SaveReplay,s),
 								"J"|"j"=>session_ctrl!(LoadIntoReplayState,s),
-								"H"|"h"=>session_ctrl!(DebugSimulation,s),
 								_=>None,
 							},
 							_=>None,
@@ -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,
Author	SHA1	Message	Date
Rhys Lloyd	8801a82ee9	negative everything	2025-11-26 13:20:56 -08:00
Rhys Lloyd	9c4e49ce15	make hint_point consistent with vert	2025-11-26 12:30:06 -08:00
Rhys Lloyd	fee511e0db	load source once at runtime	2025-11-26 11:47:53 -08:00
Rhys Lloyd	c57423553a	fix it	2025-11-26 11:29:46 -08:00
Rhys Lloyd	9f5af7060f	implement lua	2025-11-26 11:09:59 -08:00
Rhys Lloyd	6ef2e41421	add mlua	2025-11-26 11:09:59 -08:00
Rhys Lloyd	84e55c557a	physics: derive Eq for Minkowski FEV	2025-11-26 09:45:03 -08:00
Rhys Lloyd	f96398cc84	remove indexing	2025-11-25 15:57:14 -08:00
Rhys Lloyd	9ff0736d50	put comment back in	2025-11-25 12:12:33 -08:00
Rhys Lloyd	c3d390dda0	use struct	2025-11-25 11:50:40 -08:00
Rhys Lloyd	eeb47abde1	reduce member fn	2025-11-25 11:43:58 -08:00
Rhys Lloyd	567354cebb	split reduce	2025-11-25 11:43:47 -08:00
Rhys Lloyd	a787bf2ab2	deconstruct	2025-11-25 11:35:11 -08:00
Rhys Lloyd	623cc8d822	refactor using Simplex enum	2025-11-25 11:30:24 -08:00
Rhys Lloyd	6da4f3b3fb	simplify perp	2025-11-25 09:49:30 -08:00
Rhys Lloyd	982b837143	fix algorithm	2025-11-25 09:32:25 -08:00
Rhys Lloyd	02b52ef748	rename	2025-11-25 09:22:46 -08:00
Rhys Lloyd	e32523e626	style	2025-11-25 09:15:25 -08:00
Rhys Lloyd	9a0c26cc97	careful relative point opti	2025-11-25 09:15:18 -08:00
Rhys Lloyd	45c2fdbb3f	work	2025-11-25 09:12:31 -08:00
Rhys Lloyd	c1d3045a77	include relative point	2025-11-25 09:09:46 -08:00
Rhys Lloyd	f1ca5a3735	fix degenerate case	2025-11-25 09:00:23 -08:00
Rhys Lloyd	3fa048434b	fix wrong	2025-11-25 09:00:13 -08:00
Rhys Lloyd	0909a62caf	use min diff	2025-11-25 08:42:05 -08:00
Rhys Lloyd	97012940cd	implement contains_point	2025-11-25 08:33:10 -08:00
Rhys Lloyd	b601667d6a	rename variable	2025-11-25 08:32:56 -08:00
Rhys Lloyd	6d5c7df14a	work	2025-11-25 08:15:45 -08:00
Rhys Lloyd	3140c0a552	reduce min dist bit width	2025-11-25 08:15:45 -08:00
Rhys Lloyd	f9a92b7a8d	FnOnce	2025-11-24 14:34:05 -08:00
Rhys Lloyd	1fa6d5c031	fast fail fn	2025-11-24 14:33:57 -08:00
Rhys Lloyd	05954bc487	more naming things	2025-11-24 14:18:06 -08:00
Rhys Lloyd	e11d96a9b3	refine naming	2025-11-24 14:07:34 -08:00
Rhys Lloyd	5ee8a02693	names	2025-11-24 13:58:11 -08:00
Rhys Lloyd	efba2a8f19	stuff	2025-11-24 13:54:18 -08:00
Rhys Lloyd	de44e19909	switch trait to closures	2025-11-24 13:42:10 -08:00
Rhys Lloyd	c7e29d05d4	insane trait just to remove if statements	2025-11-24 13:28:28 -08:00
Rhys Lloyd	6171ceab6d	refactor calculation result	2025-11-24 13:04:51 -08:00
Rhys Lloyd	41aeeefb5b	details later	2025-11-24 13:04:51 -08:00
Rhys Lloyd	1473fe8fe1	remove is more clear	2025-11-24 13:04:51 -08:00
Rhys Lloyd	ac987a2efd	remove unused	2025-11-24 13:04:51 -08:00
Rhys Lloyd	1050d824e6	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	496f838408	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	38a7aaa046	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	ce246acb43	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	3a7eeaee7f	notes	2025-11-24 13:04:51 -08:00
Rhys Lloyd	9afbd0a91d	zero	2025-11-24 13:04:51 -08:00
Rhys Lloyd	2ffa9cbe6c	idea	2025-11-24 13:04:51 -08:00
Rhys Lloyd	8dee2140e1	eugh	2025-11-24 13:04:51 -08:00
Rhys Lloyd	af9f1a218e	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	b8442274a5	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	72ba5bad63	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	d7b779170e	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	ff28c0a311	wip paste fns	2025-11-24 13:04:51 -08:00
Rhys Lloyd	69f49d3dcf	no hold ref	2025-11-24 13:04:51 -08:00
Rhys Lloyd	a91dfe07ec	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	922f80657c	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	f05e6b5995	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	e2ba15880a	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	749ace538d	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	6d9fc38ef1	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	565b53138c	work	2025-11-24 13:04:51 -08:00
Rhys Lloyd	b0668136d6	wip	2025-11-24 13:04:51 -08:00