md generic

Cargo.lock

@@ -1974,9 +1974,9 @@ dependencies = [
 
 [[package]]
 name = "luau0-src"
-version = "0.17.0+luau701"
+version = "0.15.11+luau697"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed8f8edd8aba9654a9eeb62b2fe7461589f2faf2d0a1bc04bd64c0123319b3fc"
+checksum = "bdbf698d77af7b846fab212ca666c5d597b9ff445ef1a647e181d3392e13dfdf"
 dependencies = [
  "cc",
 ]
@@ -2149,13 +2149,12 @@ dependencies = [
 
 [[package]]
 name = "mlua"
-version = "0.11.5"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "935ac67539907efcd7198137eb7358e052555f77fe1b2916600a2249351f2b33"
+checksum = "9be1c2bfc684b8a228fbaebf954af7a47a98ec27721986654a4cc2c40a20cc7e"
 dependencies = [
  "bstr",
  "either",
- "libc",
  "mlua-sys",
  "num-traits",
  "parking_lot",
@@ -2165,9 +2164,9 @@ dependencies = [
 
 [[package]]
 name = "mlua-sys"
-version = "0.9.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c968af21bf6b19fc9ca8e7b85ee16f86e4c9e3d0591de101a5608086bda0ad8"
+checksum = "3d4dc9cfc5a7698899802e97480617d9726f7da78c910db989d4d0fd4991d900"
 dependencies = [
  "cc",
  "cfg-if",
@@ -3815,7 +3814,6 @@ dependencies = [
  "arrayvec",
  "glam",
  "id",
- "mlua",
  "strafesnet_common",
 ]
 

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

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

engine/physics/src/minimum_difference.rs

@@ -3,8 +3,6 @@ use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 
 use crate::model::{DirectedEdge,FEV,MeshQuery};
-// TODO: remove mesh invert
-use crate::model::{MinkowskiMesh,MinkowskiVert};
 
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
@@ -504,10 +502,10 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+pub fn contains_point<M:MeshQuery>(mesh:&M,point:Planar64Vec3)->bool{
 	const ENABLE_FAST_FAIL:bool=true;
 	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+	minimum_difference::<ENABLE_FAST_FAIL,_,M>(&-mesh,point,
 		// on_exact
 		|is_intersecting,_simplex|{
 			is_intersecting
@@ -674,7 +672,7 @@ fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Pla
 }
 
 /// 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>>{
+fn crawl_to_closest_fev<M:MeshQuery>(mesh:&M,simplex:Simplex<3,M::Vert>,point:Planar64Vec3)->FEV::<M>{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
 	// but it doesn't matter, we will get there regardless.
@@ -721,10 +719,10 @@ fn crawl_to_closest_fev<'a>(mesh:&MinkowskiMesh<'a>,simplex:Simplex<3,MinkowskiV
 	}
 }
 
-pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<FEV<MinkowskiMesh<'a>>>{
+pub fn closest_fev_not_inside<M:MeshQuery>(mesh:&M,point:Planar64Vec3)->Option<FEV<M>>{
 	const ENABLE_FAST_FAIL:bool=false;
 	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+	minimum_difference::<ENABLE_FAST_FAIL,_,M>(&-mesh,point,
 		// on_exact
 		|is_intersecting,simplex|{
 			if is_intersecting{
@@ -843,40 +841,4 @@ fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
 	}
 }
 
-#[cfg(test)]
-mod test{
-	use super::*;
-    use crate::model::{PhysicsMesh,PhysicsMeshView};
-
-    fn mesh_contains_point(mesh:PhysicsMeshView<'_>,point:Planar64Vec3)->bool{
-		const ENABLE_FAST_FAIL:bool=true;
-		// TODO: remove mesh negation
-		minimum_difference::<ENABLE_FAST_FAIL,_,_>(&mesh,point,
-			// on_exact
-			|is_intersecting,_simplex|{
-				is_intersecting
-			},
-			// on_escape
-			|_simplex|{
-				// intersection is guaranteed at this point
-				true
-			},
-			// fast_fail value
-			||false
-		)
-	}
-
-	#[test]
-	fn test_cube_points(){
-		let mesh=PhysicsMesh::unit_cube();
-		let mesh_view=mesh.complete_mesh_view();
-		for x in -2..=2{
-			for y in -2..=2{
-				for z in -2..=2{
-					let point=vec3::int(x,y,z)>>1;
-					assert!(mesh_contains_point(mesh_view,point),"Mesh did not contain point {point}");
-				}
-			}
-		}
-	}
-}
+// TODO: unit tests

engine/physics/src/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("/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})
-}

engine/physics/src/model.rs

@@ -641,8 +641,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>>;