761 lines
20 KiB
Rust
761 lines
20 KiB
Rust
use strafesnet_common::integer::vec3;
|
|
use strafesnet_common::integer::vec3::Vector3;
|
|
use strafesnet_common::integer::{Fixed,Planar64Vec3};
|
|
|
|
use crate::model::{DirectedEdge,FEV,MeshQuery,MinkowskiMesh,MinkowskiVert};
|
|
|
|
// This algorithm is based on Lua code
|
|
// written by Trey Reynolds in 2021
|
|
|
|
type Simplex<const N:usize>=[MinkowskiVert;N];
|
|
#[derive(Clone,Copy)]
|
|
enum Simplex1_3{
|
|
Simplex1(Simplex<1>),
|
|
Simplex2(Simplex<2>),
|
|
Simplex3(Simplex<3>),
|
|
}
|
|
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]),
|
|
Simplex1_3::Simplex3([v0,v1,v2])=>Simplex2_4::Simplex4([v,v0,v1,v2]),
|
|
}
|
|
}
|
|
}
|
|
enum Simplex2_4{
|
|
Simplex2(Simplex<2>),
|
|
Simplex3(Simplex<3>),
|
|
Simplex4(Simplex<4>),
|
|
}
|
|
|
|
/*
|
|
local function absDet(r, u, v, w)
|
|
if w then
|
|
return math.abs((u - r):Cross(v - r):Dot(w - r))
|
|
elseif v then
|
|
return (u - r):Cross(v - r).magnitude
|
|
elseif u then
|
|
return (u - r).magnitude
|
|
else
|
|
return 1
|
|
end
|
|
end
|
|
*/
|
|
impl Simplex2_4{
|
|
fn det_is_zero(&self,mesh:&MinkowskiMesh)->bool{
|
|
match self{
|
|
&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])=>{
|
|
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])=>{
|
|
let p0=mesh.vert(p0);
|
|
let p1=mesh.vert(p1);
|
|
p1-p0==vec3::zero()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
local function choosePerpendicularDirection(d)
|
|
local x, y, z = d.x, d.y, d.z
|
|
local best = math.min(x*x, y*y, z*z)
|
|
if x*x == best then
|
|
return Vector3.new(y*y + z*z, -x*y, -x*z)
|
|
elseif y*y == best then
|
|
return Vector3.new(-x*y, x*x + z*z, -y*z)
|
|
else
|
|
return Vector3.new(-x*z, -y*z, x*x + y*y)
|
|
end
|
|
end
|
|
*/
|
|
fn choose_perpendicular_direction(d:Planar64Vec3)->Planar64Vec3{
|
|
let x=d.x.abs();
|
|
let y=d.y.abs();
|
|
let z=d.z.abs();
|
|
if x<y&&x<z{
|
|
Vector3::new([Fixed::ZERO,-d.z,d.y])
|
|
}else if y<z{
|
|
Vector3::new([d.z,Fixed::ZERO,-d.x])
|
|
}else{
|
|
Vector3::new([-d.y,d.x,Fixed::ZERO])
|
|
}
|
|
}
|
|
|
|
const fn choose_any_direction()->Planar64Vec3{
|
|
vec3::X
|
|
}
|
|
|
|
fn reduce1(
|
|
[v0]:Simplex<1>,
|
|
mesh:&MinkowskiMesh,
|
|
point:Planar64Vec3,
|
|
)->Reduced{
|
|
// --debug.profilebegin("reduceSimplex0")
|
|
// local a = a1 - a0
|
|
let p0=mesh.vert(v0);
|
|
|
|
// local p = -a
|
|
let p=-(p0+point);
|
|
|
|
// local direction = p
|
|
let mut dir=p;
|
|
|
|
// if direction.magnitude == 0 then
|
|
// direction = chooseAnyDirection()
|
|
if dir==vec3::zero(){
|
|
dir=choose_any_direction();
|
|
}
|
|
|
|
// return direction, a0, a1
|
|
Reduced{
|
|
dir,
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
}
|
|
}
|
|
|
|
// local function reduceSimplex1(a0, a1, b0, b1)
|
|
fn reduce2(
|
|
[v0,v1]:Simplex<2>,
|
|
mesh:&MinkowskiMesh,
|
|
point:Planar64Vec3,
|
|
)->Reduced{
|
|
// --debug.profilebegin("reduceSimplex1")
|
|
// local a = a1 - a0
|
|
// local b = b1 - b0
|
|
let p0=mesh.vert(v0);
|
|
let p1=mesh.vert(v1);
|
|
|
|
// local p = -a
|
|
// local u = b - a
|
|
let p=-(p0+point);
|
|
let u=p1-p0;
|
|
|
|
// -- modify to take into account the radiuses
|
|
// local p_u = p:Dot(u)
|
|
let p_u=p.dot(u);
|
|
|
|
// if p_u >= 0 then
|
|
if !p_u.is_negative(){
|
|
// local direction = u:Cross(p):Cross(u)
|
|
let direction=u.cross(p).cross(u);
|
|
|
|
// if direction.magnitude == 0 then
|
|
if direction==vec3::zero(){
|
|
return Reduced{
|
|
dir:choose_perpendicular_direction(u),
|
|
simplex:Simplex1_3::Simplex2([v0,v1]),
|
|
};
|
|
}
|
|
|
|
// -- modify the direction to take into account a0R and b0R
|
|
// return direction, a0, a1, b0, b1
|
|
return Reduced{
|
|
dir:direction.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex2([v0,v1]),
|
|
};
|
|
}
|
|
|
|
// local direction = p
|
|
let mut dir=p;
|
|
|
|
// if direction.magnitude == 0 then
|
|
if dir==vec3::zero(){
|
|
dir=choose_perpendicular_direction(u);
|
|
}
|
|
|
|
// return direction, a0, a1
|
|
Reduced{
|
|
dir,
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
}
|
|
}
|
|
|
|
// local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
|
|
fn reduce3(
|
|
[v0,mut v1,v2]:Simplex<3>,
|
|
mesh:&MinkowskiMesh,
|
|
point:Planar64Vec3,
|
|
)->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);
|
|
|
|
// local p = -a
|
|
// local u = b - a
|
|
// local v = c - a
|
|
let p=-(p0+point);
|
|
let mut u=p1-p0;
|
|
let v=p2-p0;
|
|
|
|
// local uv = u:Cross(v)
|
|
// local up = u:Cross(p)
|
|
// local pv = p:Cross(v)
|
|
// local uv_up = uv:Dot(up)
|
|
// local uv_pv = uv:Dot(pv)
|
|
let mut uv=u.cross(v);
|
|
let mut up=u.cross(p);
|
|
let pv=p.cross(v);
|
|
let uv_up=uv.dot(up);
|
|
let uv_pv=uv.dot(pv);
|
|
|
|
// if uv_up >= 0 and uv_pv >= 0 then
|
|
if !uv_up.is_negative()&&!uv_pv.is_negative(){
|
|
// local uvp = uv:Dot(p)
|
|
let uvp=uv.dot(p);
|
|
|
|
// local direction = uvp < 0 and -uv or uv
|
|
let direction=if uvp.is_negative(){
|
|
-uv
|
|
}else{
|
|
uv
|
|
};
|
|
|
|
// return direction, a0, a1, b0, b1, c0, c1
|
|
return Reduced{
|
|
dir:direction.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex3([v0,v1,v2]),
|
|
};
|
|
}
|
|
|
|
// local u_u = u:Dot(u)
|
|
// local v_v = v:Dot(v)
|
|
// local uDist = uv_up/(u_u*v.magnitude)
|
|
// local vDist = uv_pv/(v_v*u.magnitude)
|
|
// local minDist2 = math.min(uDist, vDist)
|
|
let u_dist=uv_up*v.length();
|
|
let v_dist=uv_pv*u.length();
|
|
|
|
// if vDist == minDist2 then
|
|
if v_dist<u_dist{
|
|
u=v;
|
|
up=-pv;
|
|
uv=-uv;
|
|
// b0 = c0
|
|
// b1 = c1
|
|
v1=v2;
|
|
}
|
|
|
|
// local p_u = p:Dot(u)
|
|
let p_u=p.dot(u);
|
|
|
|
// if p_u >= 0 then
|
|
if !p_u.is_negative(){
|
|
// local direction = up:Cross(u)
|
|
let direction=up.cross(u);
|
|
// if direction.magnitude == 0 then
|
|
if direction==vec3::zero(){
|
|
// direction = uv
|
|
return Reduced{
|
|
dir:uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex2([v0,v1]),
|
|
};
|
|
}
|
|
|
|
// return direction, a0, a1, b0, b1
|
|
return Reduced{
|
|
dir:direction.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex2([v0,v1]),
|
|
};
|
|
}
|
|
|
|
// local direction = p
|
|
let dir=p;
|
|
// if direction.magnitude == 0 then
|
|
if dir==vec3::zero(){
|
|
// direction = uv
|
|
return Reduced{
|
|
dir:uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
};
|
|
}
|
|
// return direction, a0, a0
|
|
Reduced{
|
|
dir,
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
}
|
|
}
|
|
|
|
// local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
|
|
fn reduce4(
|
|
[v0,mut v1,mut v2,v3]:Simplex<4>,
|
|
mesh:&MinkowskiMesh,
|
|
point:Planar64Vec3,
|
|
)->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);
|
|
|
|
// local p = -a
|
|
// local u = b - a
|
|
// local v = c - a
|
|
// local w = d - a
|
|
let p=-(p0+point);
|
|
let mut u=p1-p0;
|
|
let mut v=p2-p0;
|
|
let w=p3-p0;
|
|
|
|
// local uv = u:Cross(v)
|
|
// local vw = v:Cross(w)
|
|
// local wu = w:Cross(u)
|
|
// local uvw = uv:Dot(w)
|
|
// local pvw = vw:Dot(p)
|
|
// local upw = wu:Dot(p)
|
|
// local uvp = uv:Dot(p)
|
|
let mut uv=u.cross(v);
|
|
let vw=v.cross(w);
|
|
let wu=w.cross(u);
|
|
let uv_w=uv.dot(w);
|
|
let pv_w=vw.dot(p);
|
|
let up_w=wu.dot(p);
|
|
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(){
|
|
// 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
|
|
return Reduce::Escape([v0,v1,v2,v3]);
|
|
}
|
|
|
|
// local uvwSign = uvw < 0 and -1 or uvw > 0 and 1 or 0
|
|
// local uvDist = uvp*uvwSign/uv.magnitude
|
|
// local vwDist = pvw*uvwSign/vw.magnitude
|
|
// local wuDist = upw*uvwSign/wu.magnitude
|
|
// local minDist3 = math.min(uvDist, vwDist, wuDist)
|
|
let uv_dist=uv_p.mul_sign(uv_w);
|
|
let vw_dist=pv_w.mul_sign(uv_w);
|
|
let wu_dist=up_w.mul_sign(uv_w);
|
|
let wu_len=wu.length();
|
|
let uv_len=uv.length();
|
|
let vw_len=vw.length();
|
|
|
|
if vw_dist*wu_len<wu_dist*vw_len{
|
|
// if vwDist == minDist3 then
|
|
if vw_dist*uv_len<uv_dist*vw_len{
|
|
(u,v)=(v,w);
|
|
uv=vw;
|
|
// uv_p=pv_w; // unused
|
|
// b0, c0 = c0, d0
|
|
// b1, c1 = c1, d1
|
|
(v1,v2)=(v2,v3);
|
|
}else{
|
|
v2=v3;
|
|
}
|
|
}else{
|
|
// elseif wuDist == minDist3 then
|
|
if wu_dist*uv_len<uv_dist*wu_len{
|
|
(u,v)=(w,u);
|
|
uv=wu;
|
|
// uv_p=up_w; // unused
|
|
// b0, c0 = d0, b0
|
|
// b1, c1 = d1, b1
|
|
// before [a,b,c,d]
|
|
(v1,v2)=(v3,v1);
|
|
// after [a,d,b]
|
|
}else{
|
|
v2=v3;
|
|
}
|
|
}
|
|
|
|
// local up = u:Cross(p)
|
|
// local pv = p:Cross(v)
|
|
// local uv_up = uv:Dot(up)
|
|
// local uv_pv = uv:Dot(pv)
|
|
let mut up=u.cross(p);
|
|
let pv=p.cross(v);
|
|
let uv_up=uv.dot(up);
|
|
let uv_pv=uv.dot(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(){
|
|
return Reduce::Reduced(Reduced{
|
|
dir:uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex3([v0,v1,v2]),
|
|
});
|
|
}else{
|
|
return Reduce::Reduced(Reduced{
|
|
dir:-uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex3([v0,v1,v2]),
|
|
});
|
|
}
|
|
}
|
|
|
|
// local u_u = u:Dot(u)
|
|
// local v_v = v:Dot(v)
|
|
// local uDist = uv_up/(u_u*v.magnitude)
|
|
// local vDist = uv_pv/(v_v*u.magnitude)
|
|
// local minDist2 = math.min(uDist, vDist)
|
|
let u_dist=uv_up*v.length();
|
|
let v_dist=uv_pv*u.length();
|
|
|
|
// if vDist == minDist2 then
|
|
if v_dist<u_dist{
|
|
u=v;
|
|
up=-pv;
|
|
uv=-uv;
|
|
// b0 = c0
|
|
// b1 = c1
|
|
v1=v2;
|
|
}
|
|
|
|
// local p_u = p:Dot(u)
|
|
let p_u=p.dot(u);
|
|
|
|
// if p_u >= 0 then
|
|
if !p_u.is_negative(){
|
|
// local direction = up:Cross(u)
|
|
let direction=up.cross(u);
|
|
// if direction.magnitude == 0 then
|
|
if direction==vec3::zero(){
|
|
// direction = uvw < 0 and uv or -uv
|
|
// return direction, a0, a1, b0, b1
|
|
if uv_w.is_negative(){
|
|
return Reduce::Reduced(Reduced{
|
|
dir:uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex2([v0,v1]),
|
|
});
|
|
}else{
|
|
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:direction.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex2([v0,v1]),
|
|
});
|
|
}
|
|
|
|
// local direction = p
|
|
let dir=p;
|
|
// if direction.magnitude == 0 then
|
|
if dir==vec3::zero(){
|
|
// direction = uvw < 0 and uv or -uv
|
|
if uv_w.is_negative(){
|
|
return Reduce::Reduced(Reduced{
|
|
dir:uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
});
|
|
}else{
|
|
return Reduce::Reduced(Reduced{
|
|
dir:-uv.narrow_1().unwrap(),
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
});
|
|
}
|
|
}
|
|
|
|
// return direction, a0, a1
|
|
Reduce::Reduced(Reduced{
|
|
dir,
|
|
simplex:Simplex1_3::Simplex1([v0]),
|
|
})
|
|
}
|
|
|
|
struct Reduced{
|
|
dir:Planar64Vec3,
|
|
simplex:Simplex1_3,
|
|
}
|
|
|
|
enum Reduce{
|
|
Escape(Simplex<4>),
|
|
Reduced(Reduced),
|
|
}
|
|
|
|
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)),
|
|
Self::Simplex4(simplex)=>reduce4(simplex,mesh,point),
|
|
}
|
|
}
|
|
}
|
|
|
|
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{
|
|
Done,//found closest vert, no edges are better
|
|
Vert(MinkowskiVert),//transition to vert
|
|
}
|
|
enum EV{
|
|
Vert(MinkowskiVert),
|
|
Edge(crate::model::MinkowskiEdge),
|
|
}
|
|
|
|
impl MinkowskiMesh<'_>{
|
|
fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,point:Planar64Vec3)->Transition{
|
|
let mut best_transition=Transition::Done;
|
|
for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
|
|
//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);
|
|
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>,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
|
|
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,mut best_distance_squared:Fixed<2,64>,point:Planar64Vec3)->EV{
|
|
loop{
|
|
match self.next_transition_vert(vert_id,&mut best_distance_squared,point){
|
|
Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,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_fev(&self,simplex:Simplex<3>,point:Planar64Vec3)->FEV::<Self>{
|
|
let (vert_id,best_distance_squared)=simplex.into_iter().map(|vert_id|{
|
|
let diff=point-self.vert(vert_id);
|
|
(vert_id,diff.dot(diff))
|
|
}).min_by_key(|&(_,d)|d).unwrap();
|
|
//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(vert_id,best_distance_squared,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(){
|
|
//both faces cannot pass this condition, return early if one does.
|
|
return FEV::Face(face_id);
|
|
}
|
|
}
|
|
FEV::Edge(edge_id)
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct OhNoes;
|
|
pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->Option<Result<FEV<MinkowskiMesh<'a>>,OhNoes>>{
|
|
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])=>Ok(FEV::Vert(-v0)),
|
|
Simplex1_3::Simplex2([v0,v1])=>{
|
|
// invert
|
|
let (v0,v1)=(-v0,-v1);
|
|
// TODO: handle non-canonnical multi-edge spanning edges
|
|
// dumbest stupidest brute force search
|
|
let v0e=mesh.vert_edges(v0);
|
|
for &v0e in v0e.as_ref(){
|
|
// check opposite vertex to see if it is v1
|
|
if mesh.edge_verts(v0e.as_undirected()).as_ref()[v0e.parity() as usize]==v1{
|
|
return Some(Ok(FEV::Edge(v0e.as_undirected())));
|
|
}
|
|
}
|
|
Err(OhNoes)
|
|
},
|
|
Simplex1_3::Simplex3([v0,v1,v2])=>{
|
|
// invert
|
|
let (v0,v1,v2)=(-v0,-v1,-v2);
|
|
let p0=mesh.vert(v0);
|
|
let p1=mesh.vert(v1);
|
|
let p2=mesh.vert(v2);
|
|
// spanning simplex normal
|
|
let n=(p2-p0).cross(p1-p0);
|
|
// Scan opposite vertices for coplanar ones and find a coplanar face
|
|
for &v0e in mesh.vert_edges(v0).as_ref(){
|
|
// check if opposite vertex is coplanar
|
|
let o0=mesh.edge_verts(v0e.as_undirected()).as_ref()[v0e.parity() as usize];
|
|
let o0p=mesh.vert(o0);
|
|
if n.dot(o0p-p0).is_zero(){
|
|
// always take left face (or right idk just use the parity)
|
|
let f0=mesh.edge_faces(v0e.as_undirected()).as_ref()[v0e.parity() as usize];
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
// Shimmy to the side until you find a face that contains the closest point
|
|
Err(OhNoes)
|
|
},
|
|
})
|
|
},
|
|
// 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!()
|
|
)
|
|
}
|
|
|
|
// local function minimumDifference(
|
|
// queryP, radiusP,
|
|
// queryQ, radiusQ,
|
|
// exitRadius, testIntersection
|
|
// )
|
|
fn minimum_difference<const ENABLE_FAST_FAIL:bool,T>(
|
|
mesh:&MinkowskiMesh,
|
|
point:Planar64Vec3,
|
|
on_exact:impl FnOnce(bool,Simplex1_3)->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;
|
|
// degenerate case
|
|
if initial_axis==vec3::zero(){
|
|
initial_axis=choose_any_direction();
|
|
}
|
|
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);
|
|
let Reduced{dir:mut direction,simplex:mut simplex_small}=reduce1([last_point],mesh,point);
|
|
|
|
// exitRadius = testIntersection and 0 or exitRadius or 1/0
|
|
// for _ = 1, 100 do
|
|
loop{
|
|
// 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);
|
|
|
|
// if -direction:Dot(next_point) > (exitRadius + radiusP + radiusQ)*direction.magnitude then
|
|
if ENABLE_FAST_FAIL&&direction.dot(next_pos+point).is_negative(){
|
|
return on_fast_fail();
|
|
}
|
|
|
|
let simplex_big=simplex_small.push_front(next_point);
|
|
|
|
// 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){
|
|
// 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);
|
|
}
|
|
|
|
// direction, a0, a1, b0, b1, c0, c1, d0, d1 = reduceSimplex(new_point_p, new_point_q, a0, a1, b0, b1, c0, c1)
|
|
match simplex_big.reduce(mesh,point){
|
|
// if a and b and c and d then
|
|
Reduce::Escape(simplex)=>{
|
|
// Enough information to conclude that the meshes are intersecting.
|
|
// Topology information is computed if needed.
|
|
return on_escape(simplex);
|
|
},
|
|
Reduce::Reduced(reduced)=>{
|
|
direction=reduced.dir;
|
|
simplex_small=reduced.simplex;
|
|
},
|
|
}
|
|
|
|
// next loop this will be a
|
|
last_pos=next_pos;
|
|
}
|
|
}
|