porting mistake

Cargo.lock

@@ -3904,6 +3904,7 @@ dependencies = [
  "arrayvec",
  "glam",
  "id",
+ "mlua",
  "strafesnet_common",
 ]
 

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

engine/graphics/src/model.rs

@@ -8,12 +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],
-	pub normal:[f32;3],
-}
 #[derive(Clone,Copy,id::Id)]
 pub struct IndexedGraphicsMeshOwnedRenderConfigId(u32);
 pub struct IndexedGraphicsMeshOwnedRenderConfig{

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]

engine/physics/src/lib.rs

@@ -3,6 +3,7 @@ mod face_crawler;
 mod model;
 mod push_solve;
 mod minimum_difference;
+mod minimum_difference_lua;
 
 pub mod physics;
 

engine/physics/src/minimum_difference.rs

@@ -10,13 +10,20 @@ use crate::model::{MinkowskiMesh,MinkowskiVert};
 // written by Trey Reynolds in 2021
 
 type Simplex<const N:usize,Vert>=[Vert;N];
-#[derive(Clone,Copy)]
+#[derive(Clone,Copy,Debug)]
 enum Simplex1_3<Vert>{
 	Simplex1(Simplex<1,Vert>),
 	Simplex2(Simplex<2,Vert>),
 	Simplex3(Simplex<3,Vert>),
 }
 impl<Vert> Simplex1_3<Vert>{
+	fn len(&self)->usize{
+		match self{
+			Simplex1_3::Simplex1(_)=>1,
+			Simplex1_3::Simplex2(_)=>2,
+			Simplex1_3::Simplex3(_)=>3,
+		}
+	}
 	fn push_front(self,v:Vert)->Simplex2_4<Vert>{
 		match self{
 			Simplex1_3::Simplex1([v0])=>Simplex2_4::Simplex2([v,v0]),
@@ -136,12 +143,15 @@ 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;
@@ -165,6 +175,7 @@ fn reduce2<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
+	println!("reduce2");
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -222,6 +233,7 @@ fn reduce3<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduced<M::Vert>{
+	println!("reduce3");
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -236,6 +248,7 @@ fn reduce3<M:MeshQuery>(
 	let p=-(p0+point);
 	let mut u=p1-p0;
 	let v=p2-p0;
+	println!("p={p} u={u} v={v}");
 
 	// local uv = u:Cross(v)
 	// local up = u:Cross(p)
@@ -259,6 +272,7 @@ fn reduce3<M:MeshQuery>(
 		}else{
 			uv
 		};
+		println!("and we got here?? direction={direction:?}");
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
@@ -331,6 +345,7 @@ fn reduce4<M:MeshQuery>(
 	mesh:&M,
 	point:Planar64Vec3,
 )->Reduce<M::Vert>{
+	println!("reduce4");
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -366,9 +381,11 @@ fn reduce4<M:MeshQuery>(
 	let uv_p=uv.dot(p);
 
 	// 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(){
+	let a=!pv_w.div_sign(uv_w).is_negative();
+	let b=!up_w.div_sign(uv_w).is_negative();
+	let c=!uv_p.div_sign(uv_w).is_negative();
+	println!("a={a} b={b} c={c}");
+	if a&&b&&c{
 		// 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
@@ -751,13 +768,22 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 		},
 	}
 }
-
 pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+	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);
+	assert_eq!(hits,closest_fev_not_inside.is_none(),"algorithms disagree");
+	closest_fev_not_inside
+}
+
+fn closest_fev_not_inside_inner<'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 None;
 			}
@@ -821,6 +847,7 @@ 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);
@@ -829,6 +856,8 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	// exitRadius = testIntersection and 0 or exitRadius or 1/0
 	// for _ = 1, 100 do
 	loop{
+		println!("arity={} direction={direction}",simplex_small.len());
+
 		// new_point_p = queryP(-direction)
 		// new_point_q = queryQ(direction)
 		// local next_point = new_point_q - new_point_p
@@ -836,7 +865,11 @@ 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
-		if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
+		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");
 			return on_fast_fail();
 		}
 
@@ -845,8 +878,11 @@ 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
-		if !direction.dot(next_pos-last_pos).is_positive()
-		||simplex_big.det_is_zero(mesh){
+		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");
 			// Found enough information to compute the exact closest point.
 			// local norm = direction.unit
 			// local dist = a:Dot(norm)
@@ -859,6 +895,7 @@ 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);

engine/physics/src/minimum_difference_lua.rs

@@ -0,0 +1,173 @@
+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

@@ -91,7 +91,6 @@ 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;
@@ -527,9 +526,6 @@ 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;
@@ -649,8 +645,8 @@ pub enum MinkowskiFace{
 
 #[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
+	pub mesh0:TransformedMesh<'a>,
+	pub mesh1:TransformedMesh<'a>,
 }
 
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;

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;
@@ -287,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)]
@@ -999,45 +997,6 @@ impl PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
-	pub fn trace_ray(&self,ray:strafesnet_common::ray::Ray)->Option<ModelId>{
-		let (_time,convex_mesh_id)=self.bvh.sample_ray(&ray,Time::ZERO,Time::MAX/4,|&model,ray|{
-			let mesh=self.models.mesh(model);
-			// brute force trace every face
-			let faces=mesh.faces().filter_map(|face_id|{
-				let (n,d)=mesh.face_nd(face_id);
-				// trace ray onto face
-				// n.(o+d*t)==n.p
-				// n.o + n.d * t == n.p
-				// t == (n.p - n.o)/n.d
-				let nd=n.dot(ray.direction);
-				if nd.is_zero(){
-					return None;
-				}
-				let t=(d-n.dot(ray.origin))/nd;
-				Some((face_id,t,n))
-			});
-			let mut min=None;
-			for (face_id,t,n) in faces{
-				if let Some(min)=min&&min<t{
-					continue;
-				}
-				// check if point of intersection is behind face edges
-				// *2 because average of 2 vertices
-				let p=ray.extrapolate(t)*2;
-				let is_inside_face=mesh.face_edges(face_id).as_ref().iter().all(|&directed_edge_id|{
-					let edge_n=mesh.directed_edge_n(directed_edge_id);
-					let cross_n=edge_n.cross(n);
-					let &[vert0,vert1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
-					cross_n.dot(p)<cross_n.dot(mesh.vert(vert0)+mesh.vert(vert1))
-				});
-				if is_inside_face{
-					min=Some(t);
-				}
-			}
-			min.map(Into::into)
-		})?;
-		Some(convex_mesh_id.model_id.into())
-	}
 	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();

engine/session/src/session.rs

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

integration-testing/src/test_scenes.rs

@@ -115,3 +115,48 @@ 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.
+	// log cylinder
+	// transform=PhysicsMeshTransform { vertex: Planar64Affine3 { matrix3: Matrix { array: [[-0.00000469, 20.41880000, -0.00001730], [-3.71969533, -0.00000d38, -11.c3c43095], [-11.c3c41e7d, 0.00000000, 3.719690ac]] }, translation: Vector { array: [-908.de600000, 28f.e5240000, 24c.c4d80000] } }, normal: Matrix { array: [[-0.00002d857e4861a0, 147.71af629e398c1d05, -0.0000ead3c8730458], [-6f.147da83887600000, -0.0001ab1b4486f8fc, -23d.04a89b8def680000], [-23d.04aae32fa55a8280, 0.0000018177694d73, 6f.147e3a4136524bf8]] }, det: 2942.07be40fdd83c96df87d34320 }
+	// wedge part
+	// transform=PhysicsMeshTransform { vertex: Planar64Affine3 { matrix3: Matrix { array: [[-4.9ba5b000, 0.00000000, 0.00000000], [0.00000000, 3.85509c00, 0.00000000], [0.00000000, 0.00000000, -4.9ba5b000]] }, translation: Vector { array: [-781.30380000, 35b.dab40000, 11c.a4160000] } }, normal: Matrix { array: [[-10.3941970ff7400000, 0.0000000000000000, 0.0000000000000000], [0.0000000000000000, 15.3bcf8e5c59000000, 0.0000000000000000], [0.0000000000000000, 0.0000000000000000, -10.3941970ff7400000]] }, det: 4a.c2312159fcd9163c00000000 }
+	builder.push_mesh_instance(mesh,Planar64Affine3::new(
+		mat3::Matrix3::from_cols([vec3::raw_array([-0x4_9ba5b000, 0x0_00000000, 0x0_00000000]), vec3::raw_array([0x0_00000000, 0x3_85509c00, 0x0_00000000]), vec3::raw_array([0x0_00000000, 0x0_00000000, -0x4_9ba5b000])]),
+		vec3::raw_array([-0x781_30380000, 0x35b_dab40000, 0x11c_a4160000])
+	));
+	builder.build()
+}
+
+#[test]
+fn test_minimum_difference(){
+	let physics_data=test_scene_cylinder();
+	// log cylinder
+	// H p(-2329.436, 694.175, 587.190) v(0.000, -5.714, 0.000) a(0.000, -100.000, 0.000) t(56s+880000000ns)
+	// wedge part
+	// H p(-1920.041, 867.905, 284.639) v(0.000, -4.695, 0.000) a(0.000, -100.000, 0.000) t(119s+260000000ns)
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::try_from_f32_array([-1920.041, 867.905, 284.639]).unwrap(),
+		vec3::try_from_f32_array([0.000, -4.695, 0.000]).unwrap(),
+		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));
+}

strafe-client/src/physics_worker.rs

@@ -77,8 +77,5 @@ 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,29 +86,6 @@ fn vs_entity_texture(
 	return result;
 }
 
-@group(1)
-@binding(0)
-var<uniform> model_instance: ModelInstance;
-
-struct DebugEntityOutput {
-	@builtin(position) position: vec4<f32>,
-	@location(1) normal: vec3<f32>,
-	@location(2) view: vec3<f32>,
-};
-
-@vertex
-fn vs_debug(
-	@location(0) pos: vec3<f32>,
-	@location(1) normal: vec3<f32>,
-) -> DebugEntityOutput {
-	var position: vec4<f32> = model_instance.transform * vec4<f32>(pos, 1.0);
-	var result: DebugEntityOutput;
-	result.normal = model_instance.normal_transform * normal;
-	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
-	result.position = camera.proj * camera.view * position;
-	return result;
-}
-
 //group 2 is the skybox texture
 @group(1)
 @binding(0)
@@ -133,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;
-}