// http://roy-t.nl/index.php/2010/03/04/getting-the-left-forward-and-back-vectors-from-a-view-matrix-directly/
// FOR VIEW MATRICES: Transposed values are incorrect!! That trick only worked for OpenTK, these are non-transpose indexed values.
public static Vector3 Forward(this Matrix4 mat)
{
return(-mat.Backward());
}
/// <summary>
/// DoOverlapBoxTriangleTest
/// </summary>
/// <param name="oldBox"></param>
/// <param name="newBox"></param>
/// <param name="triangle"></param>
/// <param name="mesh"></param>
/// <param name="info"></param>
/// <param name="collTolerance"></param>
/// <param name="collisionFunctor"></param>
/// <returns>bool</returns>
private static bool DoOverlapBoxTriangleTest(Box oldBox, Box newBox,
ref IndexedTriangle triangle, TriangleMesh mesh,
ref CollDetectInfo info, float collTolerance,
CollisionFunctor collisionFunctor)
{
Matrix4 dirs0 = newBox.Orientation;
#region REFERENCE: Triangle tri = new Triangle(mesh.GetVertex(triangle.GetVertexIndex(0)),mesh.GetVertex(triangle.GetVertexIndex(1)),mesh.GetVertex(triangle.GetVertexIndex(2)));
Vector3 triVec0;
Vector3 triVec1;
Vector3 triVec2;
mesh.GetVertex(triangle.GetVertexIndex(0), out triVec0);
mesh.GetVertex(triangle.GetVertexIndex(1), out triVec1);
mesh.GetVertex(triangle.GetVertexIndex(2), out triVec2);
// Deano move tri into world space
Matrix4 transformMatrix = mesh.TransformMatrix;
Vector3.Transform(ref triVec0, ref transformMatrix, out triVec0);
Vector3.Transform(ref triVec1, ref transformMatrix, out triVec1);
Vector3.Transform(ref triVec2, ref transformMatrix, out triVec2);
Triangle tri = new Triangle(ref triVec0, ref triVec1, ref triVec2);
#endregion
#region REFERENCE Vector3 triEdge0 = (tri.GetPoint(1) - tri.GetPoint(0));
Vector3 pt0;
Vector3 pt1;
tri.GetPoint(0, out pt0);
tri.GetPoint(1, out pt1);
Vector3 triEdge0;
Vector3.Subtract(ref pt1, ref pt0, out triEdge0);
#endregion
#region REFERENCE Vector3 triEdge1 = (tri.GetPoint(2) - tri.GetPoint(1));
Vector3 pt2;
tri.GetPoint(2, out pt2);
Vector3 triEdge1;
Vector3.Subtract(ref pt2, ref pt1, out triEdge1);
#endregion
#region REFERENCE Vector3 triEdge2 = (tri.GetPoint(0) - tri.GetPoint(2));
Vector3 triEdge2;
Vector3.Subtract(ref pt0, ref pt2, out triEdge2);
#endregion
triEdge0.Normalize();
triEdge1.Normalize();
triEdge2.Normalize();
// BEN-OPTIMISATION: Replaced loops with code that requires no looping.
// The new code is faster, has less allocations and math especially
// since the method returns as soon as it finds a non-overlapping axis,
// i.e. Before irreleveat allocations occur.
#region "Old (less efficient) code"
/*Vector3 triNormal = triangle.Plane.Normal;
*
* // the 15 potential separating axes
* const int numAxes = 13;
* Vector3[] axes = new Vector3[numAxes];
*
* axes[0] = triNormal;
* axes[1] = dirs0.Right;
* axes[2] = dirs0.Up;
* axes[3] = dirs0.Backward;
* Vector3.Cross(ref axes[1], ref triEdge0, out axes[4]);
* Vector3.Cross(ref axes[1], ref triEdge1, out axes[5]);
* Vector3.Cross(ref axes[1], ref triEdge2, out axes[6]);
* Vector3.Cross(ref axes[2], ref triEdge0, out axes[7]);
* Vector3.Cross(ref axes[2], ref triEdge1, out axes[8]);
* Vector3.Cross(ref axes[2], ref triEdge2, out axes[9]);
* Vector3.Cross(ref axes[3], ref triEdge0, out axes[10]);
* Vector3.Cross(ref axes[3], ref triEdge1, out axes[11]);
* Vector3.Cross(ref axes[3], ref triEdge2, out axes[12]);
*
* // the overlap depths along each axis
* float[] overlapDepths = new float[numAxes];
*
* // see if the boxes are separate along any axis, and if not keep a
* // record of the depths along each axis
* int i;
* for (i = 0; i < numAxes; ++i)
* {
* overlapDepths[i] = 1.0f;
* if (Disjoint(out overlapDepths[i], axes[i], newBox, tri, collTolerance))
* return false;
* }
*
* // The box overlap, find the separation depth closest to 0.
* float minDepth = float.MaxValue;
* int minAxis = -1;
*
* for (i = 0; i < numAxes; ++i)
* {
* // If we can't normalise the axis, skip it
* float l2 = axes[i].LengthSquared;
* if (l2 < JiggleMath.Epsilon)
* continue;
*
* // Normalise the separation axis and the depth
* float invl = 1.0f / (float)System.Math.Sqrt(l2);
* axes[i] *= invl;
* overlapDepths[i] *= invl;
*
* // If this axis is the minimum, select it
* if (overlapDepths[i] < minDepth)
* {
* minDepth = overlapDepths[i];
* minAxis = i;
* }
* }
*
* if (minAxis == -1)
* return false;
*
* // Make sure the axis is facing towards the 0th box.
* // if not, invert it
* Vector3 D = newBox.GetCentre() - tri.Centre;
* Vector3 N = axes[minAxis];
* float depth = overlapDepths[minAxis];*/
#endregion
#region "Optimised code"
Vector3 triNormal = triangle.Plane.Normal;
Vector3 right = dirs0.Right();
Vector3 up = dirs0.Up();
Vector3 backward = dirs0.Backward();
float testDepth;
if (Disjoint(out testDepth, ref triNormal, newBox, ref tri, collTolerance))
{
return(false);
}
float depth = testDepth;
Vector3 N = triNormal;
if (Disjoint(out testDepth, ref right, newBox, ref tri, collTolerance))
{
return(false);
}
if (testDepth < depth)
{
depth = testDepth;
N = right;
}
if (Disjoint(out testDepth, ref up, newBox, ref tri, collTolerance))
{
return(false);
}
if (testDepth < depth)
{
depth = testDepth;
N = up;
}
if (Disjoint(out testDepth, ref backward, newBox, ref tri, collTolerance))
{
return(false);
}
if (testDepth < depth)
{
depth = testDepth;
N = backward;
}
Vector3 axis;
Vector3.Cross(ref right, ref triEdge0, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref right, ref triEdge1, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref right, ref triEdge2, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref up, ref triEdge0, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref up, ref triEdge1, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref up, ref triEdge2, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref backward, ref triEdge0, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref backward, ref triEdge1, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
Vector3.Cross(ref backward, ref triEdge2, out axis);
if (Disjoint(out testDepth, ref axis, newBox, ref tri, collTolerance))
{
return(false);
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
}
/*if (N == Vector3.Zero)
* return (false);*/
Vector3 D = newBox.GetCentre() - tri.Centre;
N.Normalize();
int i;
#endregion
if (Vector3.Dot(D, N) < 0.0f)
{
N *= -1;
}
Vector3 boxOldPos = (info.Skin0.Owner != null) ? info.Skin0.Owner.OldPosition : Vector3.Zero;
Vector3 boxNewPos = (info.Skin0.Owner != null) ? info.Skin0.Owner.Position : Vector3.Zero;
Vector3 meshPos = (info.Skin1.Owner != null) ? info.Skin1.Owner.OldPosition : Vector3.Zero;
List <Vector3> pts = new List <Vector3>();
//pts.Clear();
const float combinationDist = 0.05f;
GetBoxTriangleIntersectionPoints(pts, newBox, tri, depth + combinationDist);
// adjust the depth
#region REFERENCE: Vector3 delta = boxNewPos - boxOldPos;
Vector3 delta;
Vector3.Subtract(ref boxNewPos, ref boxOldPos, out delta);
#endregion
#region REFERENCE: float oldDepth = depth + Vector3.Dot(delta, N);
float oldDepth;
Vector3.Dot(ref delta, ref N, out oldDepth);
oldDepth += depth;
#endregion
unsafe
{
// report collisions
int numPts = pts.Count;
#if USE_STACKALLOC
SmallCollPointInfo *collPts = stackalloc SmallCollPointInfo[MaxLocalStackSCPI];
#else
SmallCollPointInfo[] collPtArray = SCPIStackAlloc();
fixed(SmallCollPointInfo *collPts = collPtArray)
#endif
{
if (numPts > 0)
{
if (numPts >= MaxLocalStackSCPI)
{
numPts = MaxLocalStackSCPI - 1;
}
// adjust positions
for (i = 0; i < numPts; ++i)
{
// BEN-OPTIMISATION: Reused existing SmallCollPointInfo and inlined vector substraction.
collPts[i].R0.X = pts[i].X - boxNewPos.X;
collPts[i].R0.Y = pts[i].Y - boxNewPos.Y;
collPts[i].R0.Z = pts[i].Z - boxNewPos.Z;
collPts[i].R1.X = pts[i].X - meshPos.X;
collPts[i].R1.Y = pts[i].Y - meshPos.Y;
collPts[i].R1.Z = pts[i].Z - meshPos.Z;
collPts[i].InitialPenetration = oldDepth;
}
collisionFunctor.CollisionNotify(ref info, ref N, collPts, numPts);
#if !USE_STACKALLOC
FreeStackAlloc(collPtArray);
#endif
return(true);
}
else
{
#if !USE_STACKALLOC
FreeStackAlloc(collPtArray);
#endif
return(false);
}
}
}
}
/// <summary>
/// Detect BoxBox Collisions.
/// </summary>
/// <param name="info"></param>
/// <param name="collTolerance"></param>
/// <param name="collisionFunctor"></param>
public override void CollDetect(CollDetectInfo info, float collTolerance, CollisionFunctor collisionFunctor)
{
Box box0 = info.Skin0.GetPrimitiveNewWorld(info.IndexPrim0) as Box;
Box box1 = info.Skin1.GetPrimitiveNewWorld(info.IndexPrim1) as Box;
Box oldBox0 = info.Skin0.GetPrimitiveOldWorld(info.IndexPrim0) as Box;
Box oldBox1 = info.Skin1.GetPrimitiveOldWorld(info.IndexPrim1) as Box;
Matrix4 dirs0 = box0.Orientation;
Matrix4 dirs1 = box1.Orientation;
Vector3 box0_Right = dirs0.Right();
Vector3 box0_Up = dirs0.Up();
Vector3 box0_Backward = dirs0.Backward();
Vector3 box1_Right = dirs1.Right();
Vector3 box1_Up = dirs1.Up();
Vector3 box1_Backward = dirs1.Backward();
float testDepth;
if (Disjoint(out testDepth, ref box0_Right, box0, box1, collTolerance))
{
return;
}
float depth = testDepth;
Vector3 N = box0_Right;
int minAxis = 0;
if (Disjoint(out testDepth, ref box0_Up, box0, box1, collTolerance))
{
return;
}
if (testDepth < depth)
{
depth = testDepth;
N = box0_Up;
minAxis = 1;
}
if (Disjoint(out testDepth, ref box0_Backward, box0, box1, collTolerance))
{
return;
}
if (testDepth < depth)
{
depth = testDepth;
N = box0_Backward;
minAxis = 2;
}
if (Disjoint(out testDepth, ref box1_Right, box0, box1, collTolerance))
{
return;
}
if (testDepth < depth)
{
depth = testDepth;
N = box1_Right;
minAxis = 3;
}
if (Disjoint(out testDepth, ref box1_Up, box0, box1, collTolerance))
{
return;
}
if (testDepth < depth)
{
depth = testDepth;
N = box1_Up;
minAxis = 4;
}
if (Disjoint(out testDepth, ref box1_Backward, box0, box1, collTolerance))
{
return;
}
if (testDepth < depth)
{
depth = testDepth;
N = box1_Backward;
minAxis = 5;
}
Vector3 axis;
Vector3.Cross(ref box0_Right, ref box1_Right, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 6;
}
Vector3.Cross(ref box0_Right, ref box1_Up, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 7;
}
Vector3.Cross(ref box0_Right, ref box1_Backward, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 8;
}
Vector3.Cross(ref box0_Up, ref box1_Right, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 9;
}
Vector3.Cross(ref box0_Up, ref box1_Up, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 10;
}
Vector3.Cross(ref box0_Up, ref box1_Backward, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 11;
}
Vector3.Cross(ref box0_Backward, ref box1_Right, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 12;
}
Vector3.Cross(ref box0_Backward, ref box1_Up, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 13;
}
Vector3.Cross(ref box0_Backward, ref box1_Backward, out axis);
if (Disjoint(out testDepth, ref axis, box0, box1, collTolerance))
{
return;
}
testDepth *= 1.0f / (float)System.Math.Sqrt(axis.X * axis.X + axis.Y * axis.Y + axis.Z * axis.Z);
if (testDepth < depth)
{
depth = testDepth;
N = axis;
minAxis = 14;
}
Vector3 D = box1.GetCentre() - box0.GetCentre();
N.Normalize();
int i;
/*seperatingAxes[0] = dirs0.Right;
* seperatingAxes[1] = dirs0.Up;
* seperatingAxes[2] = dirs0.Backward;
* seperatingAxes[3] = dirs1.Right;
* seperatingAxes[4] = dirs1.Up;
* seperatingAxes[5] = dirs1.Backward;
* Vector3.Cross(ref seperatingAxes[0], ref seperatingAxes[3], out seperatingAxes[6]);
* Vector3.Cross(ref seperatingAxes[0], ref seperatingAxes[4], out seperatingAxes[7]);
* Vector3.Cross(ref seperatingAxes[0], ref seperatingAxes[5], out seperatingAxes[8]);
* Vector3.Cross(ref seperatingAxes[1], ref seperatingAxes[3], out seperatingAxes[9]);
* Vector3.Cross(ref seperatingAxes[1], ref seperatingAxes[4], out seperatingAxes[10]);
* Vector3.Cross(ref seperatingAxes[1], ref seperatingAxes[5], out seperatingAxes[11]);
* Vector3.Cross(ref seperatingAxes[2], ref seperatingAxes[3], out seperatingAxes[12]);
* Vector3.Cross(ref seperatingAxes[2], ref seperatingAxes[4], out seperatingAxes[13]);
* Vector3.Cross(ref seperatingAxes[2], ref seperatingAxes[5], out seperatingAxes[14]);
*
*
* // see if the boxes are separate along any axis, and if not keep a
* // record of the depths along each axis
* int i;
* for (i = 0; i < 15; ++i)
* {
* // If we can't normalise the axis, skip it
* float l2 = seperatingAxes[i].LengthSquared;
*
* if (l2 < JiggleMath.Epsilon) continue;
*
* overlapDepth[i] = float.MaxValue;
*
* if (Disjoint(out overlapDepth[i], ref seperatingAxes[i], box0, box1, collTolerance))
* return;
* }
*
* // The box overlap, find the seperation depth closest to 0.
* float minDepth = float.MaxValue;
* int minAxis = -1;
*
* for (i = 0; i < 15; ++i)
* {
* // If we can't normalise the axis, skip it
* float l2 = seperatingAxes[i].LengthSquared;
* if (l2 < JiggleMath.Epsilon) continue;
*
* // Normalise the separation axis and depth
* float invl = 1.0f / (float)System.Math.Sqrt(l2);
* seperatingAxes[i] *= invl;
* overlapDepth[i] *= invl;
*
* // If this axis is the minmum, select it
* if (overlapDepth[i] < minDepth)
* {
* minDepth = overlapDepth[i];
* minAxis = i;
* }
* }
*
* if (minAxis == -1)
* return;
*
* // Make sure the axis is facing towards the 0th box.
* // if not, invert it
* Vector3 D = box1.GetCentre() - box0.GetCentre();
* Vector3 N = seperatingAxes[minAxis];
* float depth = overlapDepth[minAxis];*/
if (Vector3.Dot(D, N) > 0.0f)
{
N *= -1.0f;
}
float minA = OpenTKHelper.Min(box0.SideLengths.X, OpenTKHelper.Min(box0.SideLengths.Y, box0.SideLengths.Z));
float minB = OpenTKHelper.Min(box1.SideLengths.X, OpenTKHelper.Min(box1.SideLengths.Y, box1.SideLengths.Z));
float combinationDist = 0.05f * OpenTKHelper.Min(minA, minB);
// the contact points
bool contactPointsFromOld = true;
contactPts.Clear();
if (depth > -JiggleMath.Epsilon)
{
GetBoxBoxIntersectionPoints(contactPts, oldBox0, oldBox1, combinationDist, collTolerance);
}
int numPts = contactPts.Count;
if (numPts == 0)
{
contactPointsFromOld = false;
GetBoxBoxIntersectionPoints(contactPts, box0, box1, combinationDist, collTolerance);
}
numPts = contactPts.Count;
Vector3 body0OldPos = (info.Skin0.Owner != null) ? info.Skin0.Owner.OldPosition : Vector3.Zero;
Vector3 body1OldPos = (info.Skin1.Owner != null) ? info.Skin1.Owner.OldPosition : Vector3.Zero;
Vector3 body0NewPos = (info.Skin0.Owner != null) ? info.Skin0.Owner.Position : Vector3.Zero;
Vector3 body1NewPos = (info.Skin1.Owner != null) ? info.Skin1.Owner.Position : Vector3.Zero;
#region REFERENCE: Vector3 bodyDelta = body0NewPos - body0OldPos - body1NewPos + body1OldPos;
Vector3 bodyDelta;
Vector3.Subtract(ref body0NewPos, ref body0OldPos, out bodyDelta);
Vector3.Subtract(ref bodyDelta, ref body1NewPos, out bodyDelta);
Vector3.Add(ref bodyDelta, ref body1OldPos, out bodyDelta);
#endregion
#region REFERENCE: float bodyDeltaLen = Vector3.Dot(bodyDelta,N);
float bodyDeltaLen;
Vector3.Dot(ref bodyDelta, ref N, out bodyDeltaLen);
#endregion
float oldDepth = depth + bodyDeltaLen;
unsafe
{
#if USE_STACKALLOC
SmallCollPointInfo *collPts = stackalloc SmallCollPointInfo[MaxLocalStackSCPI];
#else
SmallCollPointInfo[] collPtArray = SCPIStackAlloc();
fixed(SmallCollPointInfo *collPts = collPtArray)
#endif
{
int numCollPts = 0;
Vector3 SATPoint;
switch (minAxis)
{
// Box0 face, Box1 corner collision
case 0:
case 1:
case 2:
{
// Get the lowest point on the box1 along box1 normal
GetSupportPoint(out SATPoint, box1, -N);
break;
}
// We have a Box2 corner/Box1 face collision
case 3:
case 4:
case 5:
{
// Find with vertex on the triangle collided
GetSupportPoint(out SATPoint, box0, N);
break;
}
// We have an edge/edge collision
default:
/*case 6:
* case 7:
* case 8:
* case 9:
* case 10:
* case 11:
* case 12:
* case 13:
* case 14:*/
{
{
// Retrieve which edges collided.
i = minAxis - 6;
int ia = i / 3;
int ib = i - ia * 3;
// find two P0, P1 point on both edges.
Vector3 P0, P1;
GetSupportPoint(out P0, box0, N);
GetSupportPoint(out P1, box1, -N);
// Find the edge intersection.
// plane along N and F, and passing through PB
Vector3 box0Orient, box1Orient;
JiggleUnsafe.Get(ref box0.transform.Orientation, ia, out box0Orient);
JiggleUnsafe.Get(ref box1.transform.Orientation, ib, out box1Orient);
#region REFERENCE: Vector3 planeNormal = Vector3.Cross(N, box1Orient[ib]);
Vector3 planeNormal;
Vector3.Cross(ref N, ref box1Orient, out planeNormal);
#endregion
#region REFERENCE: float planeD = Vector3.Dot(planeNormal, P1);
float planeD;
Vector3.Dot(ref planeNormal, ref P1, out planeD);
#endregion
// find the intersection t, where Pintersection = P0 + t*box edge dir
#region REFERENCE: float div = Vector3.Dot(box0Orient, planeNormal);
float div;
Vector3.Dot(ref box0Orient, ref planeNormal, out div);
#endregion
// plane and ray colinear, skip the intersection.
if (System.Math.Abs(div) < JiggleMath.Epsilon)
{
return;
}
float t = (planeD - Vector3.Dot(P0, planeNormal)) / div;
// point on edge of box0
#region REFERENCE: P0 += box0Orient * t;
P0 = Vector3.Add(Vector3.Multiply(box0Orient, t), P0);
#endregion
#region REFERENCE: SATPoint = (P0 + (0.5f * depth) * N);
Vector3.Multiply(ref N, 0.5f * depth, out SATPoint);
Vector3.Add(ref SATPoint, ref P0, out SATPoint);
#endregion
}
break;
}
/*default:
* throw new Exception("Impossible switch");*/
}
// distribute the depth according to the distance to the SAT point
if (numPts > 0)
{
float minDist = float.MaxValue;
float maxDist = float.MinValue;
for (i = 0; i < numPts; ++i)
{
float dist = Distance.PointPointDistance(contactPts[i].Pos, SATPoint);
if (dist < minDist)
{
minDist = dist;
}
if (dist > maxDist)
{
maxDist = dist;
}
}
if (maxDist < minDist + JiggleMath.Epsilon)
{
maxDist = minDist + JiggleMath.Epsilon;
}
// got some intersection points
for (i = 0; i < numPts; ++i)
{
float minDepthScale = 0.0f;
float dist = Distance.PointPointDistance(contactPts[i].Pos, SATPoint);
float depthDiv = System.Math.Max(JiggleMath.Epsilon, maxDist - minDist);
float depthScale = (dist - minDist) / depthDiv;
depth = (1.0f - depthScale) * oldDepth + minDepthScale * depthScale * oldDepth;
if (contactPointsFromOld)
{
if (numCollPts < MaxLocalStackSCPI)
{
// BEN-OPTIMISATION: Instead of allocating a new SmallCollPointInfo we reuse the existing one.
collPts[numCollPts].R0 = contactPts[i].Pos - body0OldPos;
collPts[numCollPts].R1 = contactPts[i].Pos - body1OldPos;
collPts[numCollPts++].InitialPenetration = depth;
}
}
else
{
if (numCollPts < MaxLocalStackSCPI)
{
// BEN-OPTIMISATION: Instead of allocating a new SmallCollPointInfo we reuse the existing one.
collPts[numCollPts].R0 = contactPts[i].Pos - body0NewPos;
collPts[numCollPts].R1 = contactPts[i].Pos - body1NewPos;
collPts[numCollPts++].InitialPenetration = depth;
}
}
}
}
else
{
#region REFERENCE: collPts.Add(new CollPointInfo(SATPoint - body0NewPos, SATPoint - body1NewPos, oldDepth));
//collPts.Add(new CollPointInfo(SATPoint - body0NewPos, SATPoint - body1NewPos, oldDepth));
Vector3 cp0;
Vector3.Subtract(ref SATPoint, ref body0NewPos, out cp0);
Vector3 cp1;
Vector3.Subtract(ref SATPoint, ref body1NewPos, out cp1);
if (numCollPts < MaxLocalStackSCPI)
{
// BEN-OPTIMISATION: Instead of allocating a new SmallCollPointInfo we reuse the existing one.
collPts[numCollPts].R0 = cp0;
collPts[numCollPts].R1 = cp1;
collPts[numCollPts++].InitialPenetration = oldDepth;
}
#endregion
}
// report Collisions
collisionFunctor.CollisionNotify(ref info, ref N, collPts, numCollPts);
}
#if !USE_STACKALLOC
FreeStackAlloc(collPtArray);
#endif
}
}