mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-26 00:56:19 +00:00
684 lines
19 KiB
C++
684 lines
19 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "stdpacs.h"
|
|
|
|
#include "nel/pacs/edge_collide.h"
|
|
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
|
|
|
|
|
|
namespace NLPACS
|
|
{
|
|
|
|
|
|
static const float EdgeCollideEpsilon= 1e-5f;
|
|
|
|
|
|
// ***************************************************************************
|
|
void CEdgeCollide::make(const CVector2f &p0, const CVector2f &p1)
|
|
{
|
|
P0= p0;
|
|
P1= p1;
|
|
// translation axis of the edge.
|
|
Dir= P1-P0;
|
|
Dir.normalize();
|
|
A0= P0*Dir;
|
|
A1= P1*Dir;
|
|
// line equation.
|
|
Norm.x= Dir.y;
|
|
Norm.y= -Dir.x;
|
|
C= - P0*Norm;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CRational64 CEdgeCollide::testPointMove(const CVector2f &start, const CVector2f &end, TPointMoveProblem &moveBug)
|
|
{
|
|
/*
|
|
To have a correct test (with no float precision problem):
|
|
- test first if there is collision beetween the 2 edges:
|
|
- test if first edge collide the other line.
|
|
- test if second edge collide the other line.
|
|
- if both true, yes, there is a collision.
|
|
- compute time of collision.
|
|
*/
|
|
|
|
|
|
// *this must be a correct edge.
|
|
if(P0==P1)
|
|
{
|
|
moveBug= EdgeNull;
|
|
return -1;
|
|
}
|
|
|
|
// if no movement, no collision.
|
|
if(start==end)
|
|
return 1;
|
|
|
|
// NB those edges are snapped (1/256 for edgeCollide, and 1/1024 for start/end), so no float problem here.
|
|
// precision is 20 bits.
|
|
CVector2f normEdge;
|
|
CVector2f normMove;
|
|
CVector2f deltaEdge;
|
|
CVector2f deltaMove;
|
|
|
|
// compute normal of the edge (not normalized, because no need, and for precision problem).
|
|
deltaEdge= P1-P0;
|
|
normEdge.x= -deltaEdge.y;
|
|
normEdge.y= deltaEdge.x;
|
|
|
|
// compute normal of the movement (not normalized, because no need, and for precision problem).
|
|
deltaMove= end-start;
|
|
normMove.x= -deltaMove.y;
|
|
normMove.y= deltaMove.x;
|
|
|
|
// distance from points of movment against edge line. Use double, because of multiplication.
|
|
// precision is now 43 bits.
|
|
double moveD0= (double)normEdge.x*(double)(start.x-P0.x) + (double)normEdge.y*(double)(start.y-P0.y);
|
|
double moveD1= (double)normEdge.x*(double)(end.x -P0.x) + (double)normEdge.y*(double)(end.y -P0.y);
|
|
|
|
// distance from points of edge against movement line. Use double, because of multiplication.
|
|
// precision is now 43 bits.
|
|
double edgeD0= (double)normMove.x*(double)(P0.x-start.x) + (double)normMove.y*(double)(P0.y-start.y);
|
|
double edgeD1= (double)normMove.x*(double)(P1.x-start.x) + (double)normMove.y*(double)(P1.y-start.y);
|
|
|
|
|
|
// If both edges intersect lines (including endpoints), there is a collision, else none.
|
|
sint sgnMove0, sgnMove1;
|
|
sgnMove0= fsgn(moveD0);
|
|
sgnMove1= fsgn(moveD1);
|
|
|
|
// special case if the 2 edges lies on the same line.
|
|
if(sgnMove0==0 && sgnMove1==0)
|
|
{
|
|
// must test if there is a collision. if yes, problem.
|
|
// project all the points on the line of the edge.
|
|
// Use double because of multiplication. precision is now 43 bits.
|
|
double moveA0= (double)deltaEdge.x*(double)(start.x-P0.x) + (double)deltaEdge.y*(double)(start.y-P0.y);
|
|
double moveA1= (double)deltaEdge.x*(double)(end.x -P0.x) + (double)deltaEdge.y*(double)(end.y -P0.y);
|
|
double edgeA0= 0;
|
|
double edgeA1= (double)deltaEdge.x*(double)deltaEdge.x + (double)deltaEdge.y*(double)deltaEdge.y;
|
|
|
|
// Test is there is intersection (endpoints included). if yes, return -1. else return 1 (no collision at all).
|
|
if(moveA1>=edgeA0 && edgeA1>=moveA0)
|
|
{
|
|
moveBug= ParallelEdges;
|
|
return -1;
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
// if on same side of the line=> there is no collision.
|
|
if( sgnMove0==sgnMove1)
|
|
return 1;
|
|
|
|
// test edge against move line.
|
|
sint sgnEdge0, sgnEdge1;
|
|
sgnEdge0= fsgn(edgeD0);
|
|
sgnEdge1= fsgn(edgeD1);
|
|
|
|
// should not have this case, because tested before with (sgnMove==0 && sgnMove1==0).
|
|
nlassert(sgnEdge0!=0 || sgnEdge1!=0);
|
|
|
|
|
|
// if on same side of the line, no collision against this edge.
|
|
if( sgnEdge0==sgnEdge1 )
|
|
return 1;
|
|
|
|
// Here the edges intersect, but ensure that there is no limit problem.
|
|
if(sgnEdge0==0 || sgnEdge1==0)
|
|
{
|
|
moveBug= TraverseEndPoint;
|
|
return -1;
|
|
}
|
|
else if(sgnMove1==0)
|
|
{
|
|
moveBug= StopOnEdge;
|
|
return -1;
|
|
}
|
|
else if(sgnMove0==0)
|
|
{
|
|
// this should not arrive.
|
|
moveBug= StartOnEdge;
|
|
return -1;
|
|
}
|
|
|
|
|
|
// Here, there is a normal collision, just compute it.
|
|
// Because of Division, there is a precision lost in double. So compute a CRational64.
|
|
// First, compute numerator and denominator in the highest precision. this is 1024*1024 because of prec multiplication.
|
|
double numerator= (0-moveD0)*1024*1024;
|
|
double denominator= (moveD1-moveD0)*1024*1024;
|
|
sint64 numeratorInt= (sint64)numerator;
|
|
sint64 denominatorInt= (sint64)denominator;
|
|
/*
|
|
nlassert(numerator == numeratorInt);
|
|
nlassert(denominator == denominatorInt);
|
|
*/
|
|
/*
|
|
if (numerator != numeratorInt)
|
|
nlwarning("numerator(%f) != numeratorInt(%" NL_I64 "d)", numerator, numeratorInt);
|
|
if (denominator != denominatorInt)
|
|
nlwarning("denominator(%f) != denominatorInt(%" NL_I64 "d)", denominator, denominatorInt);
|
|
*/
|
|
return CRational64(numeratorInt, denominatorInt);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
static inline float testCirclePoint(const CVector2f &start, const CVector2f &delta, float radius, const CVector2f &point)
|
|
{
|
|
// factors of the qaudratic: at^2 + bt + c=0
|
|
float a,b,c;
|
|
float dta;
|
|
float r0, r1, res;
|
|
CVector2f relC, relV;
|
|
|
|
// As long as delta is not NULL (ensured in testCircleMove() ), this code should not generate Divide by 0.
|
|
|
|
// compute quadratic..
|
|
relC= start-point;
|
|
relV= delta;
|
|
a= relV.x*relV.x + relV.y*relV.y;
|
|
// a should be >0. BUT BECAUSE OF PRECISION PROBLEM, it may be ==0, and then cause
|
|
// divide by zero (because b may be near 0, but not 0)
|
|
if(a==0)
|
|
{
|
|
// in this case the move is very small. return 0 if the point is in the circle and if we go toward the point
|
|
if(relC.norm()<radius && relC*delta<0)
|
|
return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
b= 2* (relC.x*relV.x + relC.y*relV.y);
|
|
c= relC.x*relC.x + relC.y*relC.y - radius*radius;
|
|
// compute delta of the quadratic.
|
|
dta= b*b - 4*a*c; // b^2-4ac
|
|
if(dta>=0)
|
|
{
|
|
dta= (float)sqrt(dta);
|
|
r0= (-b -dta)/(2*a);
|
|
r1= (-b +dta)/(2*a);
|
|
// since a>0, r0<=r1.
|
|
if(r0>r1)
|
|
swap(r0,r1);
|
|
// if r1 is negative, then we are out and go away from this point. OK.
|
|
if(r1<=0)
|
|
{
|
|
res= 1;
|
|
}
|
|
// if r0 is positive, then we may collide this point.
|
|
else if(r0>=0)
|
|
{
|
|
res= min(1.f, r0);
|
|
}
|
|
else // r0<0 && r1>0. the point is already in the sphere!!
|
|
{
|
|
//nlinfo("COL: Point problem: %.2f, %.2f. b=%.2f", r0, r1, b);
|
|
// we allow the movement only if we go away from this point.
|
|
// this is true if the derivative at t=0 is >=0 (because a>0).
|
|
if(b>0)
|
|
res= 1; // go out.
|
|
else
|
|
res=0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// never hit this point along this movement.
|
|
res= 1;
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
float CEdgeCollide::testCircleMove(const CVector2f &start, const CVector2f &delta, float radius, CVector2f &normal)
|
|
{
|
|
// If the movement is NULL, return 1 (no collision!)
|
|
if( delta.isNull() )
|
|
return 1;
|
|
|
|
// distance from point to line.
|
|
double dist= start*Norm + C;
|
|
// projection of speed on normal.
|
|
double speed= delta*Norm;
|
|
|
|
// test if the movement is against the line or not.
|
|
bool sensPos= dist>0;
|
|
bool sensSpeed= speed>0;
|
|
|
|
// Does the point intersect the line?
|
|
dist= fabs(dist) - radius;
|
|
speed= fabs(speed);
|
|
if( dist > speed )
|
|
return 1;
|
|
|
|
// if not already in collision with the line, test when it collides.
|
|
// ===============================
|
|
if(dist>=0)
|
|
{
|
|
// if signs are equals, same side of the line, so we allow the circle to leave the line.
|
|
if(sensPos==sensSpeed )
|
|
return 1;
|
|
|
|
// if speed is 0, it means that movement is parralel to the line => never collide.
|
|
if(speed==0)
|
|
return 1;
|
|
|
|
// collide the line, at what time.
|
|
double t= dist/speed;
|
|
|
|
|
|
// compute the collision position of the Circle on the edge.
|
|
// this gives the center of the sphere at the collision point.
|
|
CVector2d proj= CVector2d(start) + CVector2d(delta)*t;
|
|
// must add radius vector.
|
|
proj+= Norm * (sensSpeed?radius:-radius);
|
|
// compute projection on edge.
|
|
double aProj= proj*Dir;
|
|
|
|
// if on the interval of the edge.
|
|
if( aProj>=A0 && aProj<=A1)
|
|
{
|
|
// collision occurs on interior of the edge. the normal to return is +- Norm.
|
|
if(sensPos) // if algebric distance of start position was >0.
|
|
normal= Norm;
|
|
else
|
|
normal= -Norm;
|
|
|
|
// return time of collision.
|
|
return (float)t;
|
|
}
|
|
}
|
|
// else, must test if circle collide segment at t=0. if yes, return 0.
|
|
// ===============================
|
|
else
|
|
{
|
|
// There is just need to test if projection of circle's center onto the line hit the segment.
|
|
// This is not a good test to know if a circle intersect a segment, but other cases are
|
|
// managed with test of endPoints of the segment after.
|
|
float aProj= start*Dir;
|
|
|
|
// if on the interval of the edge.
|
|
if( aProj>=A0 && aProj<=A1)
|
|
{
|
|
// if signs are equals, same side of the line, so we allow the circle to leave the edge.
|
|
/* Special case: do not allow to leave the edge if we are too much in the edge.
|
|
It is important for CGlobalRetriever::testCollisionWithCollisionChains() because of the
|
|
"SURFACEMOVE NOT DETECTED" Problem.
|
|
Suppose we can walk on this chain SA/SB (separate Surface A/SurfaceB). Suppose we are near this edge,
|
|
and on Surface SA, and suppose there is another chain SB/SC the circle collide with. If we
|
|
return 1 (no collision), SB/SC won't be detected (because only SA/?? chains will be tested) and
|
|
so the cylinder will penetrate SB/SC...
|
|
This case arise at best if chains SA/SB and chain SB/SC do an angle of 45deg
|
|
*/
|
|
if(sensPos==sensSpeed && (-dist)<0.5*radius)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
// hit the interior of the edge, and sensPos!=sensSpeed. So must stop now!!
|
|
// collision occurs on interior of the edge. the normal to return is +- Norm.
|
|
if(sensPos) // if algebric distance of start position was >0.
|
|
normal= Norm;
|
|
else
|
|
normal= -Norm;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// In this case, the Circle do not hit the edge on the interior, but may hit on borders.
|
|
// ===============================
|
|
// Then, we must compute collision sphere-points.
|
|
float tmin, ttmp;
|
|
// first point.
|
|
tmin= testCirclePoint(start, delta, radius, P0);
|
|
// second point.
|
|
ttmp= testCirclePoint(start, delta, radius, P1);
|
|
tmin= min(tmin, ttmp);
|
|
|
|
// if collision occurs, compute normal of collision.
|
|
if(tmin<1)
|
|
{
|
|
// to which point we collide?
|
|
CVector2f colPoint= tmin==ttmp? P1 : P0;
|
|
// compute position of the entity at collision.
|
|
CVector2f colPos= start + delta*tmin;
|
|
|
|
// and so we have this normal (the perpendicular of the tangent at this point).
|
|
normal= colPos - colPoint;
|
|
normal.normalize();
|
|
}
|
|
|
|
return tmin;
|
|
}
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CEdgeCollide::testEdgeMove(const CVector2f &q0, const CVector2f &q1, const CVector2f &delta, float &tMin, float &tMax, bool &normalOnBox)
|
|
{
|
|
double a,b,cv,cc, d,e,f;
|
|
CVector2d tmp;
|
|
|
|
// compute D1 line equation of q0q1. bx - ay + c(t)=0, where c is function of time [0,1].
|
|
// ===========================
|
|
tmp= q1 - q0; // NB: along time, the direction doesn't change.
|
|
// Divide by norm()^2, so that a projection on this edge is true if the proj is in interval [0,1].
|
|
tmp/= tmp.sqrnorm();
|
|
a= tmp.x;
|
|
b= tmp.y;
|
|
// c= - q0(t)*CVector2d(b,-a). but since q0(t) is a function of time t (q0+delta*t), compute cv, and cc.
|
|
// so c= cv*t + cc.
|
|
cv= - CVector2d(b,-a)*delta;
|
|
cc= - CVector2d(b,-a)*q0;
|
|
|
|
// compute D2 line equation of P0P1. ex - dy + f=0.
|
|
// ===========================
|
|
tmp= P1 - P0;
|
|
// Divide by norm()^2, so that a projection on this edge is true if the proj is in interval [0,1].
|
|
tmp/= tmp.sqrnorm();
|
|
d= tmp.x;
|
|
e= tmp.y;
|
|
f= - CVector2d(e,-d)*P0;
|
|
|
|
|
|
// Solve system.
|
|
// ===========================
|
|
/*
|
|
Compute the intersection I of 2 lines across time.
|
|
We have the system:
|
|
bx - ay + c(t)=0
|
|
ex - dy + f=0
|
|
|
|
which solve for:
|
|
det= ae-bd (0 <=> // lines)
|
|
x(t)= (d*c(t) - fa) / det
|
|
y(t)= (e*c(t) - fb) / det
|
|
*/
|
|
|
|
// determinant of matrix2x2.
|
|
double det= a*e - b*d;
|
|
// if to near of 0. (take delta for reference of test).
|
|
if(det==0 || fabs(det)<delta.norm()*EdgeCollideEpsilon)
|
|
return false;
|
|
|
|
// intersection I(t)= pInt + vInt*t.
|
|
CVector2d pInt, vInt;
|
|
pInt.x= ( d*cc - f*a ) / det;
|
|
pInt.y= ( e*cc - f*b ) / det;
|
|
vInt.x= ( d*cv ) / det;
|
|
vInt.y= ( e*cv ) / det;
|
|
|
|
|
|
// Project Intersection.
|
|
// ===========================
|
|
/*
|
|
Now, we project x,y onto each line D1 and D2, which gives u(t) and v(t), each one giving the parameter of
|
|
the parametric line function. When it is in [0,1], we are on the edge.
|
|
|
|
u(t)= (I(t)-q0(t)) * CVector2d(a,b) = uc + uv*t
|
|
v(t)= (I(t)-P0) * CVector2d(d,e) = vc + vv*t
|
|
*/
|
|
double uc, uv;
|
|
double vc, vv;
|
|
// NB: q0(t)= q0+delta*t
|
|
uc= (pInt-q0) * CVector2d(a,b);
|
|
uv= (vInt-delta) * CVector2d(a,b);
|
|
vc= (pInt-P0) * CVector2d(d,e);
|
|
vv= (vInt) * CVector2d(d,e);
|
|
|
|
|
|
// Compute intervals.
|
|
// ===========================
|
|
/*
|
|
Now, for each edge, compute time interval where parameter is in [0,1]. If intervals overlap, there is a collision.
|
|
*/
|
|
double tu0, tu1, tv0, tv1;
|
|
// infinite interval.
|
|
bool allU=false, allV=false;
|
|
|
|
// compute time interval for u(t).
|
|
if(uv==0 || fabs(uv)<EdgeCollideEpsilon)
|
|
{
|
|
// The intersection does not move along D1. Always projected on u(t)=uc. so if in [0,1], OK, else never collide.
|
|
if(uc<0 || uc>1)
|
|
return false;
|
|
// else suppose "always valid".
|
|
tu0 =tu1= 0;
|
|
allU= true;
|
|
}
|
|
else
|
|
{
|
|
tu0= (0-uc)/uv; // t for u(t)=0
|
|
tu1= (1-uc)/uv; // t for u(t)=1
|
|
}
|
|
|
|
// compute time interval for v(t).
|
|
if(vv==0 || fabs(vv)<EdgeCollideEpsilon)
|
|
{
|
|
// The intersection does not move along D2. Always projected on v(t)=vc. so if in [0,1], OK, else never collide.
|
|
if(vc<0 || vc>1)
|
|
return false;
|
|
// else suppose "always valid".
|
|
tv0 =tv1= 0;
|
|
allV= true;
|
|
}
|
|
else
|
|
{
|
|
tv0= (0-vc)/vv; // t for v(t)=0
|
|
tv1= (1-vc)/vv; // t for v(t)=1
|
|
}
|
|
|
|
|
|
// clip intervals.
|
|
// ===========================
|
|
// order time interval.
|
|
if(tu0>tu1)
|
|
swap(tu0, tu1); // now, [tu0, tu1] represent the time interval where line D2 hit the edge D1.
|
|
if(tv0>tv1)
|
|
swap(tv0, tv1); // now, [tv0, tv1] represent the time interval where line D1 hit the edge D2.
|
|
|
|
normalOnBox= false;
|
|
if(!allU && !allV)
|
|
{
|
|
// if intervals do not overlap, no collision.
|
|
if(tu0>tv1 || tv0>tu1)
|
|
return false;
|
|
else
|
|
{
|
|
// compute intersection of intervals.
|
|
tMin= (float)max(tu0, tv0);
|
|
tMax= (float)min(tu1, tv1);
|
|
// if collision of edgeCollide against the bbox.
|
|
if(tv0>tu0)
|
|
normalOnBox= true;
|
|
}
|
|
}
|
|
else if(allU)
|
|
{
|
|
// intersection of Infinite and V interval.
|
|
tMin= (float)tv0;
|
|
tMax= (float)tv1;
|
|
// if collision of edgeCollide against the bbox.
|
|
normalOnBox= true;
|
|
}
|
|
else if(allV)
|
|
{
|
|
// intersection of Infinite and U interval.
|
|
tMin= (float)tu0;
|
|
tMax= (float)tu1;
|
|
}
|
|
else
|
|
{
|
|
// if allU && allV, this means delta is near 0, and so there is always collision.
|
|
tMin= -1000;
|
|
tMax= 1000;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
float CEdgeCollide::testBBoxMove(const CVector2f &start, const CVector2f &delta, const CVector2f bbox[4], CVector2f &normal)
|
|
{
|
|
// distance from center to line.
|
|
float dist= start*Norm + C;
|
|
|
|
// test if the movement is against the line or not.
|
|
bool sensPos= dist>0;
|
|
// if signs are equals, same side of the line, so we allow the circle to leave the line.
|
|
/*if(sensPos==sensSpeed)
|
|
return 1;*/
|
|
|
|
|
|
// Else, do 4 test edge/edge, and return Tmin.
|
|
float tMin = 0.f, tMax = 0.f;
|
|
bool edgeCollided= false;
|
|
bool normalOnBox= false;
|
|
CVector2f boxNormal(0.f, 0.f);
|
|
for(sint i=0;i<4;i++)
|
|
{
|
|
float t0, t1;
|
|
bool nob;
|
|
CVector2f a= bbox[i];
|
|
CVector2f b= bbox[(i+1)&3];
|
|
|
|
// test move against this edge.
|
|
if(testEdgeMove(a, b, delta, t0, t1, nob))
|
|
{
|
|
if(edgeCollided)
|
|
{
|
|
tMin= min(t0, tMin);
|
|
tMax= max(t1, tMax);
|
|
}
|
|
else
|
|
{
|
|
edgeCollided= true;
|
|
tMin= t0;
|
|
tMax= t1;
|
|
}
|
|
|
|
// get normal of box against we collide.
|
|
if(tMin==t0)
|
|
{
|
|
normalOnBox= nob;
|
|
if(nob)
|
|
{
|
|
CVector2f dab;
|
|
// bbox must be CCW.
|
|
dab= b-a;
|
|
// the normal is computed so that the vector goes In the bbox.
|
|
boxNormal.x= -dab.y;
|
|
boxNormal.y= dab.x;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if collision occurs,and int the [0,1] interval...
|
|
if(edgeCollided && tMin<1 && tMax>0)
|
|
{
|
|
// compute normal of collision.
|
|
if(normalOnBox)
|
|
{
|
|
// assume collsion is an endpoint of the edge against the bbox.
|
|
normal= boxNormal;
|
|
}
|
|
else
|
|
{
|
|
// assume collision occurs on interior of the edge. the normal to return is +- Norm.
|
|
if(sensPos) // if algebric distance of start position was >0.
|
|
normal= Norm;
|
|
else
|
|
normal= -Norm;
|
|
}
|
|
|
|
// compute time of collison.
|
|
if(tMin>0)
|
|
// return time of collision.
|
|
return tMin;
|
|
else
|
|
{
|
|
// The bbox is inside the edge, at t==0. test if it goes out or not.
|
|
// accept only if we are much near the exit than the enter.
|
|
/* NB: 0.2 is an empirical value "which works well". Normally, 1 is the good value, but because of the
|
|
"SURFACEMOVE NOT DETECTED" Problem (see testCircleMove()), we must be more restrictive.
|
|
*/
|
|
if( tMax<0.2*(-tMin) )
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CEdgeCollide::testBBoxCollide(const CVector2f bbox[4])
|
|
{
|
|
// clip the edge against the edge of the bbox.
|
|
CVector2f p0= P0, p1= P1;
|
|
|
|
for(sint i=0; i<4; i++)
|
|
{
|
|
CVector2f a= bbox[i];
|
|
CVector2f b= bbox[(i+1)&3];
|
|
CVector2f delta= b-a, norm;
|
|
// sign is important. bbox is CCW. normal goes OUT the bbox.
|
|
norm.x= delta.y;
|
|
norm.y= -delta.x;
|
|
|
|
float d0= (p0-a)*norm;
|
|
float d1= (p1-a)*norm;
|
|
|
|
// if boths points are out this plane, no collision.
|
|
if( d0>0 && d1>0)
|
|
return false;
|
|
// if difference, must clip.
|
|
if( d0>0 || d1>0)
|
|
{
|
|
CVector2f intersect= p0 + (p1-p0)* ((0-d0)/(d1-d0));
|
|
if(d1>0)
|
|
p1= intersect;
|
|
else
|
|
p0= intersect;
|
|
}
|
|
}
|
|
|
|
// if a segment is still in the bbox, collision occurs.
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
} // NLPACS
|