bool Intersect(Polygon A, Polygon B)
{
for(I = 0; I < A.num_edges; I ++)
{
Vector N = Vector(-A.EdgeDir[I].y, A.EdgeDir[I].x);
if (AxisSeparatePolygons(N, A, B))
return false;
}
for(I = 0; I < B.num_edges; I ++)
{
Vector N = Vector(-B.EdgeDir[i].y, B.EdgeDir[I].x);
if (AxisSeparatePolygons (N, A, B))
return false;
}
return true;
}

void CalculateInterval(Vector Axis, Polygon P, float& min, float& max)
{
float d = Axis dot P.vertex[0]; //从坐标原点开始计算向量
min = max = d;
for(I = 0; I < P.num_vertices; I ++)
{
float d = P.vertex[I] dot Axis;
if (d < min)
min = d;
else
if(d > max)
max = d;
}
}

for(J = A.num_vertices-1, I = 0; I < A.num_vertices; J = I, I ++)
{
Vector E = A.vertex[I] – A.vertex[J];
Vector N = Vector(-E.y, E.x);

if (AxisSeparatePolygons(N, A, B))
return false;
}

bool Intersect(Polygon A, Polygon B, Vector& MTD)
{
// potential separation axes. they get converted into push
vectors Vector Axis[32];
// max of 16 vertices per polygon
int iNumAxis = 0;
for(J = A.num_vertices–1, I = 0; I < A. num_vertices; J = I, I ++)
{
Vector E = A.vertex[I] – A.vertex[J];
Axis[iNumAxis++] = Vector(-E.y, E.x);

if (AxisSeparatePolygons(N, A, B))
return false;
}
for(J = B. num_vertices–1, I = 0; I < B.num_vertices; J = I, I ++)
{
Vector E = B.vertex[I] – B.vertex[J];
Axis[iNumAxis++] = Vector(-E.y, E.x);

if (AxisSeparatePolygons (N, A, B))
return false;
}

// find the MTD among all the separation vectors
MTD = FindMTD(Axis, iNumAxis);

// makes sure the push vector is pushing A away from B
Vector D = A.Position – B.Position;
if (D dot MTD < 0.0f)
MTD = -MTD;

return true;
}

bool AxisSeparatePolygons(Vector& Axis, Polygon A, Polygon B)
{
float mina, maxa;
float minb, maxb;

CalculateInterval(Axis, A, mina, maxa);
CalculateInterval(Axis, B, minb, maxb);

if (mina > maxb || minb > maxa)
return true;

// find the interval overlap
float d0 = maxa - minb;
float d1 = maxb - mina;
float depth = (d0 < d1)? d0 : d1;

// convert the separation axis into a push vector (re-normalise
// the axis and multiply by interval overlap)
float axis_length_squared = Axis dot Axis;

Axis *= depth / axis_length_squared;
return false;
}

Vector FindMTD(Vector* PushVectors, int iNumVectors)
{
Vector MTD = PushVector[0];
float mind2 = PushVector[0] dot PushVector[0];
for(int I = 1; I < iNumVectors; I ++)
{
float d2 = PushVector[I] * PushVector[I];
if (d2 < mind2)
{
mind2 = d2;
MTD = PushVector[I];
}
}
return MTD;
}

A.Postion += MTD * 0.5f;
B.Position -= MTD * 0.5f;

bool AxisSeparatePolygons(Vector Axis, Polygon A, Polygon B, Vector Offset, Vector Vel, float& t, float tmax);

bool Collide(   const Vector* A, int Anum,
const Vector* B, int Bnum,
const Vector& xOffset, const Vector& xVel,
Vector& N, float& t)
{
if (!A || !B) return false;

// All the separation axes
// note : a maximum of 32 vertices per poly is supported
Vector xAxis[64];
float taxis[64];
int iNumAxes=0;

xAxis[iNumAxes] = Vector(-xVel.y, xVel.x);
float fVel2 = xVel * xVel;
if (fVel2 > 0.00001f)
{
if (!IntervalIntersect( A, Anum, B, Bnum, xAxis[iNumAxes], xOffset, xVel, taxis[iNumAxes], t))
return false;
iNumAxes++;
}

// test separation axes of A
for(int j = Anum-1, i = 0; i < Anum; j = i, i ++)
{
Vector E0 = A[j];
Vector E1 = A[i];
Vector E = E1 - E0;
xAxis[iNumAxes] = Vector(-E.y, E.x);

if (!IntervalIntersect( A, Anum, B, Bnum, xAxis[iNumAxes], xOffset, xVel, taxis[iNumAxes], t))
return false;

iNumAxes++;
}

// test separation axes of B
for(int j = Bnum-1, i = 0; i < Bnum; j = i, i ++)
{
Vector E0 = B[j];
Vector E1 = B[i];
Vector E = E1 - E0;
xAxis[iNumAxes] = Vector(-E.y, E.x);

if (!IntervalIntersect( A, Anum, B, Bnum, xAxis[iNumAxes], xOffset, xVel, taxis[iNumAxes], t))
return false;
iNumAxes++;
}

if (!FindMTD(xAxis, taxis, iNumAxes, N, t))
return false;

// make sure the polygons gets pushed away from each other.
if (N * xOffset < 0.0f)
N = -N;

return true;
}

bool AxisSeparatePolygons ( Vector N, Polygon A, Polygon B, Vector Offset, Vector Vel, float &t, float tmax)
{
float min0, max0;
float min1, max1;

CalculateInterval(N, A, min0, max0);
CalculateInterval(N, B, min1, max1);

float h = Offset dot N;
min0 += h;
max0 += h;

float d0 = min0 - max1; // if overlapped, do < 0
float d1 = min1 - max0; // if overlapped, d1 > 0

// separated, test dynamic intervals
if (d0 > 0.0f || d1 > 0.0f)
{
float v = Vel dot N;

// small velocity, so only the overlap test will be relevant.
if (fabs(v) < 0.0000001f)
return false;

float t0 =-d0 / v; // time of impact to d0 reaches 0
float t1 = d1 / v; // time of impact to d0 reaches 1
// sort the times.
if (t0 > t1)
{
float temp = t0;
t0 = t1;
t1 = temp;
}
// take the minimum positive
taxis = (t0 > 0.0f)? t0 : t1;

// intersection time too late or back in time, no collision
if (taxis < 0.0f || taxis > tmax)
return true;

return false;
}
else
{
// overlap. get the interval, as a the smallest of |d0| and |d1|
// return negative number to mark it as an overlap
taxis = (d0 > d1)? d0 : d1;
return false;
}
}

bool FindCollisionPlane (Vector* Axis, float* taxis, int iNumAxes, Vector& Ncoll, float& tcoll)
{
// find collision first
int mini = -1;
tcoll = 0.0f;
for(int i = 0; i < iNumAxes; i ++)
{
if (taxis[i] > 0.0f)
{
if (taxis[i] > tcoll)
{
mini = i;
tcoll = taxis[i];
Ncoll = Axis[i];
Ncoll.Normalise(); // normalise axis
}
}
}

// found a collision
if (mini != -1)
return true;

// nope, find overlaps
mini = -1;
for(int i = 0; i < iNumAxes; i ++)
{
float n = Axis[i].Normalise(); // axis length

taxis[i] /= n; // normalise interval overlap too

// remember, those numbers are negative, so take the closest to 0
if (mini == -1 || taxis[i] > tcoll)
{
mini = i;
tcoll = taxis[i];
Ncoll = Axis[i];
}
}

return (mini != -1);
}