the bug

Cargo.lock

@@ -3892,6 +3892,7 @@ dependencies = [
  "glam",
  "id",
  "strafesnet_common",
+ "strafesnet_physics",
  "strafesnet_session",
  "strafesnet_settings",
  "wgpu",
@@ -3904,7 +3905,6 @@ dependencies = [
  "arrayvec",
  "glam",
  "id",
- "mlua",
  "strafesnet_common",
 ]
 

engine/graphics/Cargo.toml

@@ -9,6 +9,7 @@ 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_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
 wgpu = "28.0.0"

engine/graphics/src/graphics.rs

@@ -5,7 +5,7 @@ use strafesnet_settings::settings;
 use strafesnet_session::session;
 use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
+use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex,DebugGraphicsVertex};
 
 pub fn required_limits()->wgpu::Limits{
 	wgpu::Limits::default()
@@ -36,12 +36,28 @@ struct GraphicsModel{
 	instance_count:u32,
 }
 
+struct DebugGraphicsSubmesh{
+	verts:Vec<strafesnet_physics::model::MeshVertId>,
+	edges:Vec<Indices>,
+	faces:Vec<Indices>,
+}
+struct DebugGraphicsMesh{
+	verts:Indices,
+	submeshes:Vec<DebugGraphicsSubmesh>,
+	vertex_buf:wgpu::Buffer,
+}
+struct DebugGraphicsModel{
+	debug_mesh_id:u32,
+	bind_group:wgpu::BindGroup,
+}
+
 struct GraphicsSamplers{
 	repeat:wgpu::Sampler,
 }
 
 struct GraphicsBindGroupLayouts{
 	model:wgpu::BindGroupLayout,
+	debug_model:wgpu::BindGroupLayout,
 }
 
 struct GraphicsBindGroups{
@@ -52,6 +68,9 @@ struct GraphicsBindGroups{
 struct GraphicsPipelines{
 	skybox:wgpu::RenderPipeline,
 	model:wgpu::RenderPipeline,
+	debug_face:wgpu::RenderPipeline,
+	debug_edge:wgpu::RenderPipeline,
+	debug_vert:wgpu::RenderPipeline,
 }
 
 struct GraphicsCamera{
@@ -132,6 +151,8 @@ pub struct GraphicsState{
 	camera_buf:wgpu::Buffer,
 	temp_squid_texture_view:wgpu::TextureView,
 	models:Vec<GraphicsModel>,
+	debug_meshes:Vec<DebugGraphicsMesh>,
+	debug_models:Vec<DebugGraphicsModel>,
 	depth_view:wgpu::TextureView,
 	staging_belt:wgpu::util::StagingBelt,
 }
@@ -166,6 +187,88 @@ impl GraphicsState{
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
+		//generate debug meshes, each debug model refers to one
+		self.debug_meshes=map.meshes.iter().map(|mesh|{
+			let vertices:Vec<DebugGraphicsVertex>=mesh.unique_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 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().map(|edge_verts|indices!(edge_verts)).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]);
+								b=c;
+							}
+						}
+						indices!(indices)
+					}).collect(),
+				}).collect()
+			}else{
+				//idc
+				Vec::new()
+			};
+
+			DebugGraphicsMesh{
+				verts:indices!((0..vertices.len() as u32).map(strafesnet_physics::model::MeshVertId::new)),
+				submeshes,
+				vertex_buf,
+			}
+		}).collect();
+
+		//generate debug models, only one will be rendered at a time
+		self.debug_models=map.models.iter().enumerate().map(|(model_id,model)|{
+			let model_uniforms=get_instances_buffer_data(&[GraphicsModelOwned{
+				transform:model.transform.into(),
+				normal_transform:glam::Mat3::from_cols_array_2d(&model.transform.matrix3.to_array().map(|row|row.map(Into::into))).inverse().transpose(),
+				color:GraphicsModelColor4::new(glam::vec4(1.0,0.0,0.0,0.2)),
+			}]);
+			let model_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+				label:Some(format!("Debug Model{} Buf",model_id).as_str()),
+				contents:bytemuck::cast_slice(&model_uniforms),
+				usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
+			});
+			let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
+				layout:&self.bind_group_layouts.debug_model,
+				entries:&[
+					wgpu::BindGroupEntry{
+						binding:0,
+						resource:model_buf.as_entire_binding(),
+					},
+				],
+				label:Some(format!("Debug Model{} Bind Group",model_id).as_str()),
+			});
+			DebugGraphicsModel{
+				debug_mesh_id:model.mesh.get(),
+				bind_group,
+			}
+		}).collect();
+
 		//generate texture view per texture
 		let texture_views:HashMap<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
@@ -608,6 +711,21 @@ impl GraphicsState{
 				},
 			],
 		});
+		let debug_model_bind_group_layout=device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor{
+			label:Some("Debug Model Bind Group Layout"),
+			entries:&[
+				wgpu::BindGroupLayoutEntry{
+					binding:0,
+					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT,
+					ty:wgpu::BindingType::Buffer{
+						ty:wgpu::BufferBindingType::Uniform,
+						has_dynamic_offset:false,
+						min_binding_size:None,
+					},
+					count:None,
+				},
+			],
+		});
 
 		let clamp_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
 			label:Some("Clamp Sampler"),
@@ -756,6 +874,14 @@ impl GraphicsState{
 			],
 			immediate_size:0,
 		});
+		let debug_model_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
+				label:None,
+				bind_group_layouts:&[
+					&camera_bind_group_layout,
+					&debug_model_bind_group_layout,
+				],
+				push_constant_ranges:&[],
+			});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
 			bind_group_layouts:&[
@@ -831,6 +957,54 @@ impl GraphicsState{
 			multiview_mask:None,
 			cache:None,
 		});
+		let mut debug_model_pipeline=wgpu::RenderPipelineDescriptor{
+			label:None,
+			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{
+				front_face:wgpu::FrontFace::Cw,
+				cull_mode:Some(wgpu::Face::Front),
+				..Default::default()
+			},
+			depth_stencil:Some(wgpu::DepthStencilState{
+				format:Self::DEPTH_FORMAT,
+				depth_write_enabled:true,
+				depth_compare:wgpu::CompareFunction::Always,
+				stencil:wgpu::StencilState::default(),
+				bias:wgpu::DepthBiasState::default(),
+			}),
+			multisample:wgpu::MultisampleState::default(),
+			multiview:None,
+			cache:None,
+		};
+		debug_model_pipeline.label=Some("Debug Face Pipeline");
+		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::TriangleList;
+		let debug_model_pipeline_face=device.create_render_pipeline(&debug_model_pipeline);
+		debug_model_pipeline.label=Some("Debug Edge Pipeline");
+		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::LineList;
+		let debug_model_pipeline_edge=device.create_render_pipeline(&debug_model_pipeline);
+		debug_model_pipeline.label=Some("Debug Vert Pipeline");
+		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::PointList;
+		let debug_model_pipeline_vert=device.create_render_pipeline(&debug_model_pipeline);
 
 		let camera=GraphicsCamera::default();
 		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
@@ -870,7 +1044,10 @@ impl GraphicsState{
 		Self{
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
-				model:model_pipeline
+				model:model_pipeline,
+				debug_face:debug_model_pipeline_face,
+				debug_edge:debug_model_pipeline_edge,
+				debug_vert:debug_model_pipeline_vert,
 			},
 			bind_groups:GraphicsBindGroups{
 				camera:camera_bind_group,
@@ -879,9 +1056,14 @@ impl GraphicsState{
 			camera,
 			camera_buf,
 			models:Vec::new(),
+			debug_meshes:Vec::new(),
+			debug_models:Vec::new(),
 			depth_view,
 			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
-			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
+			bind_group_layouts:GraphicsBindGroupLayouts{
+				model:model_bind_group_layout,
+				debug_model:debug_model_bind_group_layout,
+			},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
 		}
@@ -970,6 +1152,7 @@ impl GraphicsState{
 			rpass.set_bind_group(0,&self.bind_groups.camera,&[]);
 			rpass.set_bind_group(1,&self.bind_groups.skybox_texture,&[]);
 
+			// Draw all models.
 			rpass.set_pipeline(&self.pipelines.model);
 			for model in &self.models{
 				rpass.set_bind_group(2,&model.bind_group,&[]);
@@ -981,6 +1164,40 @@ 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_face);
+								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);
+								let indices=&mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].edges[edge.get() as usize];
+								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
+								rpass.draw_indexed(0..indices.count,0,0..1);
+							},
+							strafesnet_physics::model::FEV::Vert(vert)=>{
+								rpass.set_pipeline(&self.pipelines.debug_vert);
+								let indices=&mesh.verts;
+								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
+								let vert_id=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].verts[vert.get() as usize].get();
+								rpass.draw_indexed(0..1,vert_id as i32,0..1);
+							},
+						}
+					}
+				}
+			}
 		}
 
 		queue.submit(std::iter::once(encoder.finish()));

engine/graphics/src/model.rs

@@ -8,6 +8,11 @@ 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{

engine/physics/Cargo.toml

@@ -7,7 +7,6 @@ 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]

engine/physics/src/lib.rs

@@ -1,9 +1,8 @@
 mod body;
 mod face_crawler;
-mod model;
+pub mod model;
 mod push_solve;
 mod minimum_difference;
-mod minimum_difference_lua;
 
 pub mod physics;
 

engine/physics/src/minimum_difference.rs

@@ -10,7 +10,7 @@ use crate::model::{MinkowskiMesh,MinkowskiVert};
 // written by Trey Reynolds in 2021
 
 type Simplex<const N:usize,Vert>=[Vert;N];
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy)]
 enum Simplex1_3<Vert>{
 	Simplex1(Simplex<1,Vert>),
 	Simplex2(Simplex<2,Vert>),
@@ -136,15 +136,12 @@ fn reduce1<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
-	println!("reduce1");
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
 	let p0=mesh.vert(v0);
 
-	println!("p0={p0}");
 	// local p = -a
 	let p=-(p0+point);
-	println!("p={p}");
 
 	// local direction = p
 	let mut dir=p;
@@ -168,7 +165,6 @@ fn reduce2<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
-	println!("reduce2");
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -226,7 +222,6 @@ fn reduce3<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
-	println!("reduce3");
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -336,7 +331,6 @@ fn reduce4<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduce<M::Vert>{
-	println!("reduce4");
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -355,10 +349,6 @@ fn reduce4<M:MeshQuery>(
 	let mut u=p1-p0;
 	let mut v=p2-p0;
 	let w=p3-p0;
-	println!("p={p}");
-	println!("u={u}");
-	println!("v={v}");
-	println!("w={w}");
 
 	// local uv = u:Cross(v)
 	// local vw = v:Cross(w)
@@ -377,8 +367,8 @@ fn reduce4<M:MeshQuery>(
 
 	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
 	if !pv_w.div_sign(uv_w).is_negative()
-	 &&!up_w.div_sign(uv_w).is_negative()
-	 &&!uv_p.div_sign(uv_w).is_negative(){
+	 ||!up_w.div_sign(uv_w).is_negative()
+	 ||!uv_p.div_sign(uv_w).is_negative(){
 		// origin is contained, this is a positive detection
 		// local direction = Vector3.new(0, 0, 0)
 		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
@@ -406,6 +396,8 @@ fn reduce4<M:MeshQuery>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
+		}else{
+			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -418,6 +410,8 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}
 
@@ -429,23 +423,17 @@ fn reduce4<M:MeshQuery>(
 	let pv=p.cross(v);
 	let uv_up=uv.dot(up);
 	let uv_pv=uv.dot(pv);
-	println!("up={up}");
-	println!("pv={pv}");
-	println!("uv_up={uv_up}");
-	println!("uv_pv={uv_pv}");
 
 	// if uv_up >= 0 and uv_pv >= 0 then
 	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
 		if uv_w.is_negative(){
-			println!("a");
 			return Reduce::Reduced(Reduced{
 				dir:narrow_dir2(uv),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}else{
-			println!("b");
 			return Reduce::Reduced(Reduced{
 				dir:narrow_dir2(-uv),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
@@ -483,13 +471,11 @@ fn reduce4<M:MeshQuery>(
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
 			if uv_w.is_negative(){
-				println!("c");
 				return Reduce::Reduced(Reduced{
 					dir:narrow_dir2(uv),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}else{
-				println!("d");
 				return Reduce::Reduced(Reduced{
 					dir:narrow_dir2(-uv),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
@@ -497,7 +483,6 @@ fn reduce4<M:MeshQuery>(
 			}
 		}
 
-		println!("e");
 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
 			dir:narrow_dir3(direction),
@@ -511,13 +496,11 @@ fn reduce4<M:MeshQuery>(
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
 		if uv_w.is_negative(){
-			println!("f");
 			return Reduce::Reduced(Reduced{
 				dir:narrow_dir2(uv),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}else{
-			println!("g");
 			return Reduce::Reduced(Reduced{
 				dir:narrow_dir2(-uv),
 				simplex:Simplex1_3::Simplex1([v0]),
@@ -525,7 +508,6 @@ fn reduce4<M:MeshQuery>(
 		}
 	}
 
-	println!("h");
 	// return direction, a0, a1
 	Reduce::Reduced(Reduced{
 		dir,
@@ -553,6 +535,24 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
+pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+	const ENABLE_FAST_FAIL:bool=true;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+		// on_exact
+		|is_intersecting,_simplex|{
+			is_intersecting
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			true
+		},
+		// fast_fail value
+		||false
+	)
+}
+
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition<Vert>{
@@ -752,35 +752,27 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 	}
 }
 
-#[derive(Debug)]
-pub struct InfiniteLoop;
-pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Result<Option<FEV<MinkowskiMesh<'a>>>,InfiniteLoop>{
-	println!("=== LUA ===");
-	let (hits,_details)=crate::minimum_difference_lua::minimum_difference_details(mesh,point).unwrap();
-	println!("=== RUST ===");
-	let closest_fev_not_inside=closest_fev_not_inside_inner(mesh,point).unwrap();
-	assert_eq!(hits,closest_fev_not_inside.is_none(),"algorithms disagree");
-	Ok(closest_fev_not_inside)
-}
-
-pub fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Result<Option<FEV<MinkowskiMesh<'a>>>,InfiniteLoop>{
+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|{
-			println!("on_exact simplex={simplex:?}");
 			if is_intersecting{
-				return Ok(None);
+				return None;
 			}
 			// Convert simplex to FEV
 			// Vertices must be inverted since the mesh is inverted
-			Ok(Some(match simplex{
+			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()
+					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
+					if !matches!(ev,EV::Edge(_)){
+						println!("I can't believe it's not an edge!");
+					}
+					ev.into()
 				},
 				Simplex1_3::Simplex3([v0,v1,v2])=>{
 					// invert
@@ -788,40 +780,23 @@ pub fn closest_fev_not_inside_inner<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Ve
 					// Shimmy to the side until you find a face that contains the closest point
 					// it's ALWAYS representable as a face, but this algorithm may
 					// return E or V in edge cases but I don't think that will break the face crawler
-					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
+					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
+					if !matches!(fev,FEV::Face(_)){
+						println!("I can't believe it's not a face!");
+					}
+					fev
 				},
-			}))
+			})
 		},
 		// 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);
-			Ok(None)
+			None
 		},
 		// fast_fail value is irrelevant and will never be returned!
-		||unreachable!(),
-		||Err(InfiniteLoop),
-	)
-}
-
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
-	const ENABLE_FAST_FAIL:bool=true;
-	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
-		// on_exact
-		|is_intersecting,_simplex|{
-			is_intersecting
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			true
-		},
-		// fast_fail value
-		||false,
-		// infinite loop
-		||false,
+		||unreachable!()
 	)
 }
 
@@ -836,7 +811,6 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
 	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
 	on_fast_fail:impl FnOnce()->T,
-	on_infinite_loop:impl FnOnce()->T,
 )->T{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
@@ -847,7 +821,6 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	if initial_axis==vec3::zero(){
 		initial_axis=choose_any_direction();
 	}
-	println!("initial_axis={initial_axis}");
 	let last_point=mesh.farthest_vert(-initial_axis);
 	// this represents the 'a' value in the commented code
 	let mut last_pos=mesh.vert(last_point);
@@ -855,9 +828,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
 	// for _ = 1, 100 do
-	for _ in 0..100{
-		println!("direction={direction}");
-
+	loop{
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)
 		// local next_point = new_point_q - new_point_p
@@ -865,11 +836,7 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		let next_pos=mesh.vert(next_point);
 
 		// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
-		let d=direction.dot(next_pos+point);
-		let fast_fail=d.is_negative();
-		println!("ENABLE_FAST_FAIL={ENABLE_FAST_FAIL} fast_fail={fast_fail} next_point={} dot={d}",next_pos+point);
-		if ENABLE_FAST_FAIL&&fast_fail{
-			println!("on_fast_fail");
+		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
 			return on_fast_fail();
 		}
 
@@ -878,11 +845,8 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		// if
 		// 	direction:Dot(next_point - a) <= 0 or
 		// 	absDet(next_point, a, b, c) < 1e-6
-		let cond1=!direction.dot(next_pos-last_pos).is_positive();
-		let cond2=simplex_big.det_is_zero(mesh);
-		println!("cond1={cond1} cond2={cond2}");
-		if cond1||cond2{
-			println!("on_exact");
+		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)
@@ -895,7 +859,6 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		match simplex_big.reduce(mesh,point){
 			// if a and b and c and d then
 			Reduce::Escape(simplex)=>{
-				println!("on_escape");
 				// Enough information to conclude that the meshes are intersecting.
 				// Topology information is computed if needed.
 				return on_escape(simplex);
@@ -909,7 +872,6 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 		// next loop this will be a
 		last_pos=next_pos;
 	}
-	on_infinite_loop()
 }
 
 #[cfg(test)]
@@ -931,8 +893,7 @@ mod test{
 				true
 			},
 			// fast_fail value
-			||false,
-			||false,
+			||false
 		)
 	}
 

engine/physics/src/minimum_difference_lua.rs

@@ -1,173 +0,0 @@
-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,Option<Details>)>{
-	let md=minimum_difference(mesh,point,false)?;
-	Ok((md.hits,md.details))
-}
-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(),
-				}),
-			}),
-			&mut [
-				mlua::Value::Boolean(hits),
-				mlua::Value::Integer(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.into(),
-					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,
-	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;
-		// 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,
-			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)?,
-			mlua::Value::Nil,
-			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("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})
-}

engine/physics/src/model.rs

@@ -60,7 +60,7 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 }
 
 //Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug)]
+#[derive(Debug,Clone)]
 pub enum FEV<M:MeshQuery>{
 	Face(M::Face),
 	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
@@ -91,6 +91,7 @@ pub trait MeshQuery{
 		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
 	}
 	/// This must return a point inside the mesh.
+	#[expect(dead_code)]
 	fn hint_point(&self)->Planar64Vec3;
 	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
@@ -444,6 +445,24 @@ 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;
@@ -526,6 +545,9 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
+	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
+		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
+	}
 }
 impl MeshQuery for TransformedMesh<'_>{
 	type Face=SubmeshFaceId;
@@ -645,8 +667,8 @@ pub enum MinkowskiFace{
 
 #[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
-	pub mesh0:TransformedMesh<'a>,
-	pub mesh1:TransformedMesh<'a>,
+	mesh0:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
 }
 
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
@@ -670,14 +692,12 @@ impl MinkowskiMesh<'_>{
 			mesh1,
 		}
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Result<Option<(MinkowskiFace,GigaTime)>,crate::minimum_difference::InfiniteLoop>{
-		let Some(fev)=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?else{
-			return Ok(None);
-		};
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		//continue forwards along the body parabola
-		Ok(fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit())
+		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Result<Option<(MinkowskiFace,GigaTime)>,crate::minimum_difference::InfiniteLoop>{
+	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 time=match upper_bound{
@@ -685,16 +705,14 @@ impl MinkowskiMesh<'_>{
 			Bound::Excluded(&time)=>time,
 			Bound::Unbounded=>unimplemented!("unbounded collision out"),
 		};
-		let Some(fev)=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?else{
-			return Ok(None);
-		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?;
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
 		let infinity_body=-relative_body;
 		//continue backwards along the body parabola
-		Ok(fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+		fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
 			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time)))
+			.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

engine/physics/src/physics.rs

@@ -1,4 +1,5 @@
 use std::collections::{HashMap,HashSet};
+use crate::model::DirectedEdge;
 use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
@@ -286,7 +287,8 @@ impl PhysicsCamera{
 		.clamp(Self::ANGLE_PITCH_LOWER_LIMIT,Self::ANGLE_PITCH_UPPER_LIMIT);
 		mat3::from_rotation_yx(ax,ay)
 	}
-	fn rotation(&self)->Planar64Mat3{
+	#[inline]
+	pub fn rotation(&self)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos)
 	}
 	#[expect(dead_code)]
@@ -668,7 +670,7 @@ impl From<CollisionAttributesId> for IntersectAttributesId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-struct ContactModelId(u32);
+pub struct ContactModelId(u32);
 impl From<ContactModelId> for ModelId{
 	fn from(value:ContactModelId)->ModelId{
 		ModelId::new(value.get())
@@ -680,7 +682,7 @@ impl From<ModelId> for ContactModelId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-struct IntersectModelId(u32);
+pub struct IntersectModelId(u32);
 impl From<IntersectModelId> for ModelId{
 	fn from(value:IntersectModelId)->ModelId{
 		ModelId::new(value.get())
@@ -692,7 +694,7 @@ impl From<ModelId> for IntersectModelId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-enum PhysicsModelId{
+pub enum PhysicsModelId{
 	Contact(ContactModelId),
 	Intersect(IntersectModelId),
 }
@@ -706,9 +708,9 @@ impl From<PhysicsModelId> for ModelId{
 }
 //unique physics meshes indexed by this
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
-struct ConvexMeshId<Id>{
-	model_id:Id,
-	submesh_id:PhysicsSubmeshId,
+pub struct ConvexMeshId<Id>{
+	pub model_id:Id,
+	pub submesh_id:PhysicsSubmeshId,
 }
 impl<Id> ConvexMeshId<Id>{
 	fn map<NewId>(self,model_id:NewId)->ConvexMeshId<NewId>{
@@ -828,7 +830,7 @@ impl TouchingState{
 		}).collect();
 		crate::push_solve::push_solve(&contacts,acceleration)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time)->Result<(),crate::minimum_difference::InfiniteLoop>{
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
 		for (convex_mesh_id,face_id) in &self.contacts{
@@ -849,7 +851,7 @@ impl TouchingState{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time())?.map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -859,7 +861,6 @@ impl TouchingState{
 				}
 			}));
 		}
-		Ok(())
 	}
 }
 
@@ -998,6 +999,70 @@ 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<TransformedMesh<'static>>>{
+		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(match fev{
+			model_physics::FEV::Face(face)=>{
+				match face{
+					model_physics::MinkowskiFace::VertFace(submesh_vert_id,_)=>model_physics::FEV::Vert(submesh_vert_id),
+					model_physics::MinkowskiFace::EdgeEdge(submesh_edge_id,..)=>model_physics::FEV::Edge(submesh_edge_id),
+					model_physics::MinkowskiFace::FaceVert(submesh_face_id,_)=>model_physics::FEV::Face(submesh_face_id),
+				}
+			},
+			model_physics::FEV::Edge(edge)=>{
+				match edge{
+					model_physics::MinkowskiEdge::VertEdge(submesh_vert_id,_)=>model_physics::FEV::Vert(submesh_vert_id),
+					model_physics::MinkowskiEdge::EdgeVert(submesh_edge_id,_)=>model_physics::FEV::Edge(submesh_edge_id),
+				}
+			},
+			model_physics::FEV::Vert(vert)=>{
+				match vert{
+					model_physics::MinkowskiVert::VertVert(submesh_vert_id,_)=>model_physics::FEV::Vert(submesh_vert_id),
+				}
+			},
+		})
+	}
 	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
@@ -1200,7 +1265,7 @@ impl<'a> PhysicsContext<'a>{
 		collector.collect(state.next_move_instruction());
 
 		//check for collision ends
-		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time).unwrap();
+		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
 		//check for collision starts
 		let mut aabb=aabb::Aabb::default();
 		state.body.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1215,17 +1280,17 @@ impl<'a> PhysicsContext<'a>{
 			//no checks are needed because of the time limits.
 			let model_mesh=data.models.mesh(*convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-			let Ok(collision)=minkowski.predict_collision_in(relative_body,state.time..collector.time())else{
-				println!("Infinite loop! body={relative_body}");
-				return;
-			};
-			collector.collect(collision.map(|(face,dt)|TimedInstruction{
-				time:relative_body.time+dt.into(),
-				instruction:InternalInstruction::CollisionStart(
-					Collision::new(*convex_mesh_id,face),
-					dt
+			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
+				.map(|(face,dt)|
+					TimedInstruction{
+						time:relative_body.time+dt.into(),
+						instruction:InternalInstruction::CollisionStart(
+							Collision::new(*convex_mesh_id,face),
+							dt
+						)
+					}
 				)
-			}));
+			);
 		});
 		collector.take()
 	}
@@ -1973,7 +2038,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,Time::ZERO..Time::from_secs(10)).unwrap();
+		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>){
@@ -1991,7 +2056,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,Time::ZERO..Time::from_secs(10)).unwrap();
+		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>){

engine/session/src/session.rs

@@ -61,6 +61,7 @@ pub struct FrameState{
 	pub body:physics::Body,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
+	pub hit:Option<Hit>,
 }
 
 pub struct Simulation{
@@ -77,11 +78,12 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime,debug_model:Option<Hit>)->FrameState{
 		FrameState{
 			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
+			hit: debug_model,
 		}
 	}
 }
@@ -149,6 +151,12 @@ 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,
@@ -161,6 +169,7 @@ pub struct Session{
 	recording:Recording,
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
+	last_ray_hit:Option<Hit>,
 }
 impl Session{
 	pub fn new(
@@ -177,6 +186,7 @@ impl Session{
 			view_state:ViewState::Play,
 			recording:Default::default(),
 			replays:HashMap::new(),
+			last_ray_hit:None,
 		}
 	}
 	fn clear_recording(&mut self){
@@ -188,12 +198,30 @@ impl Session{
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time,self.last_ray_hit.clone())),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time)
+				replay.simulation.get_frame_state(time,None)
 			),
 		}
 	}
+	pub fn debug_raycast_print_model_id_if_changed(&mut self,time:SessionTime){
+		if let Some(frame_state)=self.get_frame_state(time){
+			let ray=strafesnet_common::ray::Ray{
+				origin:frame_state.body.extrapolated_position(self.simulation.timer.time(time)),
+				direction:-frame_state.camera.rotation().z_axis,
+			};
+			match self.geometry_shared.trace_ray(ray){
+				Some(convex_mesh_id)=>{
+					let closest_fev=self.geometry_shared.closest_fev_not_inside(convex_mesh_id,self.simulation.physics.body().position);
+					self.last_ray_hit=Some(Hit{
+						convex_mesh_id,
+						closest_fev,
+					});
+				},
+				None=>self.last_ray_hit=None,
+			}
+		}
+	}
 	pub fn user_settings(&self)->&UserSettings{
 		&self.user_settings
 	}

integration-testing/src/test_scenes.rs

@@ -115,40 +115,3 @@ fn bug_3(){
 	assert_eq!(body.acceleration,vec3::int(0,0,0));
 	assert_eq!(body.time,Time::from_secs(2));
 }
-
-fn test_scene_cylinder()->PhysicsData{
-	let mut builder=TestSceneBuilder::new();
-	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
-	let mesh=builder.push_mesh(strafesnet_rbx_loader::primitives::unit_cylinder(cube_face_description));
-	// place one 5x5x5 cylinder.
-	builder.push_mesh_instance(mesh,Planar64Affine3::new(
-		mat3::from_diagonal(vec3::int(5,5,5)>>1),
-		vec3::int(0,-5,0)
-	));
-	builder.build()
-}
-
-#[test]
-fn test_minimum_difference(){
-	let physics_data=test_scene_cylinder();
-	let body=strafesnet_physics::physics::Body::new(
-		vec3::int(4,1,4)>>1,
-		vec3::int(-1,-1,-2),
-		vec3::int(0,-100,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	physics.style_mut().gravity=vec3::zero();
-	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(3))
-		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
-	// touch side of part at 0,0,0
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(1));
-	// touch top of part at 5,-5,0
-	assert_eq!(phys_iter.next().unwrap().time,Time::from_secs(2));
-	assert!(phys_iter.next().is_none());
-	let body=physics.body();
-	assert_eq!(body.position,vec3::int(5+2,0,0)>>1);
-	assert_eq!(body.velocity,vec3::int(0,0,0));
-	assert_eq!(body.acceleration,vec3::int(0,0,0));
-	assert_eq!(body.time,Time::from_secs(2));
-}

integration-testing/src/tests.rs

@@ -74,39 +74,3 @@ fn physics_bug_3()->Result<(),ReplayError>{
 
 	Ok(())
 }
-
-// Infinite loop! body=p(-1796.657, 677.618, 36.959) v(3.158, -53.650, -34.435) a(-0.000, -71.276, -45.248) t(288s+440000000ns)
-// Infinite loop! body=p(-2382.440, 160.150, -379.151) v(53.632, 35.779, 44.904) a(0.000, -100.000, 0.000) t(306s+675758543ns)
-// Infinite loop! body=p(-1798.724, 731.459, 68.784) v(-17.389, 0.000, -78.087) a(0.000, 0.000, 0.000) t(284s+006980061ns)
-// Infinite loop! body=p(-1796.657, 677.618, 36.959) v(3.158, -53.650, -34.435) a(-0.000, -71.276, -45.248) t(288s+440000000ns)
-// Infinite loop! body=p(-1797.504, 738.529, 74.864) v(-3.653, 0.000, -79.917) a(0.000, 0.000, 0.000) t(282s+709871336ns)
-// Infinite loop! body=p(-1797.569, 735.449, 71.859) v(23.726, -76.309, -3.747) a(0.000, 0.000, 0.000) t(283s+325193187ns)
-
-#[test]
-fn physics_md_infinite_loop()->Result<(),ReplayError>{
-	println!("loading map file..");
-	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
-	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
-
-	// create recording
-	println!("generating models..");
-	let physics_data=PhysicsData::new(&map);
-	println!("simulating...");
-
-	//teleport to bug
-	use strafesnet_common::integer::{vec3,Time};
-	let body=strafesnet_physics::physics::Body::new(
-		vec3::try_from_f32_array([-1796.657, 677.618, 36.959]).unwrap(),
-		vec3::try_from_f32_array([3.158, -53.650, -34.435]).unwrap(),
-		vec3::int(0,-100,0),
-		Time::ZERO,
-	);
-	let mut physics=PhysicsState::new_with_body(body);
-	// wait one second to activate the bug
-	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
-		time:Time::from_millis(500),
-		instruction:strafesnet_common::physics::Instruction::Idle,
-	});
-
-	Ok(())
-}

strafe-client/src/graphics_worker.rs

@@ -34,8 +34,8 @@ pub fn new(
 			Instruction::Resize(size,user_settings)=>{
 				println!("Resizing to {:?}",size);
 				let t0=std::time::Instant::now();
-				config.width=size.width.max(1);
-				config.height=size.height.max(1);
+				config.width=640;
+				config.height=480;
 				surface.configure(&device,&config);
 				graphics.resize(&device,&config,&user_settings);
 				println!("Resize took {:?}",t0.elapsed());

strafe-client/src/physics_worker.rs

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

strafe-client/src/shader.wgsl

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