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; } }
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);
// convert the separation axis into a push vector (re-normalise // the axis and multiply by interval overlap) float axis_length_squared = Axis dot Axis;
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;
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]; } }