public static XMVector FresnelTerm(XMVector cosIncidentAngle, XMVector refractionIndex)
{
Debug.Assert(!XMVector4.IsInfinite(cosIncidentAngle), "Reviewed");
//// Result = 0.5f * (g - c)^2 / (g + c)^2 * ((c * (g + c) - 1)^2 / (c * (g - c) + 1)^2 + 1) where
//// c = CosIncidentAngle
//// g = sqrt(c^2 + RefractionIndex^2 - 1)
XMVector g = XMVector.MultiplyAdd(refractionIndex, refractionIndex, XMGlobalConstants.NegativeOne);
g = XMVector.MultiplyAdd(cosIncidentAngle, cosIncidentAngle, g);
g = g.Abs().Sqrt();
XMVector s = XMVector.Add(g, cosIncidentAngle);
XMVector d = XMVector.Subtract(g, cosIncidentAngle);
XMVector v0 = XMVector.Multiply(d, d);
XMVector v1 = XMVector.Multiply(s, s).Reciprocal();
v0 = XMVector.Multiply(XMGlobalConstants.OneHalf, v0);
v0 = XMVector.Multiply(v0, v1);
XMVector v2 = XMVector.MultiplyAdd(cosIncidentAngle, s, XMGlobalConstants.NegativeOne);
XMVector v3 = XMVector.MultiplyAdd(cosIncidentAngle, d, XMGlobalConstants.One);
v2 = XMVector.Multiply(v2, v2);
v3 = XMVector.Multiply(v3, v3);
v3 = v3.Reciprocal();
v2 = XMVector.MultiplyAdd(v2, v3, XMGlobalConstants.One);
return(XMVector.Multiply(v0, v2).Saturate());
}
public static void FastIntersectOrientedBoxPlane(
XMVector center,
XMVector extents,
XMVector axis0,
XMVector axis1,
XMVector axis2,
XMVector plane,
out XMVector outside,
out XMVector inside)
{
// Compute the distance to the center of the box.
XMVector dist = XMVector4.Dot(center, plane);
// Project the axes of the box onto the normal of the plane. Half the
// length of the projection (sometime called the "radius") is equal to
// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// axes of the box.
XMVector radius = XMVector3.Dot(plane, axis0);
radius.Y = XMVector3.Dot(plane, axis1).Y;
radius.Z = XMVector3.Dot(plane, axis2).Z;
radius = XMVector3.Dot(extents, radius.Abs());
// Outside the plane?
outside = XMVector.Greater(dist, radius);
// Fully inside the plane?
inside = XMVector.Less(dist, -radius);
}
public ContainmentType Contains(BoundingOrientedBox box)
{
if (!box.Intersects(this))
{
return(ContainmentType.Disjoint);
}
XMVector boxCenter = this.center;
XMVector boxExtents = this.extents;
// Subtract off the AABB center to remove a subtract below
XMVector o_center = box.Center - boxCenter;
XMVector o_extents = box.Extents;
XMVector o_orientation = box.Orientation;
Debug.Assert(Internal.XMQuaternionIsUnit(o_orientation), "Reviewed");
XMVector inside = XMVector.TrueInt;
for (int i = 0; i < BoundingOrientedBox.CornerCount; i++)
{
XMVector c = XMVector3.Rotate(o_extents * CollisionGlobalConstants.BoxOffsets[i], o_orientation) + o_center;
XMVector d = c.Abs();
inside = XMVector.AndInt(inside, XMVector.LessOrEqual(d, boxExtents));
}
return(XMVector3.EqualInt(inside, XMVector.TrueInt) ? ContainmentType.Contains : ContainmentType.Intersects);
}
public bool Intersects(XMVector origin, XMVector direction, out float distance)
{
Debug.Assert(Internal.XMVector3IsUnit(direction), "Reviewed");
// Load the box.
XMVector v_center = this.center;
XMVector v_extents = this.extents;
// Adjust ray origin to be relative to center of the box.
XMVector t_origin = v_center - origin;
// Compute the dot product againt each axis of the box.
// Since the axii are (1,0,0), (0,1,0), (0,0,1) no computation is necessary.
XMVector axisDotOrigin = t_origin;
XMVector axisDotDirection = direction;
// if (fabs(AxisDotDirection) <= Epsilon) the ray is nearly parallel to the slab.
XMVector isParallel = XMVector.LessOrEqual(axisDotDirection.Abs(), CollisionGlobalConstants.RayEpsilon);
// Test against all three axii simultaneously.
XMVector inverseAxisDotDirection = axisDotDirection.Reciprocal();
XMVector t1 = (axisDotOrigin - v_extents) * inverseAxisDotDirection;
XMVector t2 = (axisDotOrigin + v_extents) * inverseAxisDotDirection;
// Compute the max of min(t1,t2) and the min of max(t1,t2) ensuring we don't
// use the results from any directions parallel to the slab.
XMVector t_min = XMVector.Select(XMVector.Min(t1, t2), CollisionGlobalConstants.FltMin, isParallel);
XMVector t_max = XMVector.Select(XMVector.Max(t1, t2), CollisionGlobalConstants.FltMax, isParallel);
// t_min.x = maximum( t_min.x, t_min.y, t_min.z );
// t_max.x = minimum( t_max.x, t_max.y, t_max.z );
t_min = XMVector.Max(t_min, XMVector.SplatY(t_min)); // x = max(x,y)
t_min = XMVector.Max(t_min, XMVector.SplatZ(t_min)); // x = max(max(x,y),z)
t_max = XMVector.Min(t_max, XMVector.SplatY(t_max)); // x = min(x,y)
t_max = XMVector.Min(t_max, XMVector.SplatZ(t_max)); // x = min(min(x,y),z)
// if ( t_min > t_max ) return false;
XMVector noIntersection = XMVector.Greater(XMVector.SplatX(t_min), XMVector.SplatX(t_max));
// if ( t_max < 0.0f ) return false;
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(XMVector.SplatX(t_max), XMGlobalConstants.Zero));
// if (IsParallel && (-Extents > AxisDotOrigin || Extents < AxisDotOrigin)) return false;
XMVector parallelOverlap = axisDotOrigin.InBounds(v_extents);
noIntersection = XMVector.OrInt(noIntersection, XMVector.AndComplementInt(isParallel, parallelOverlap));
if (!Internal.XMVector3AnyTrue(noIntersection))
{
// Store the x-component to *pDist
t_min.StoreFloat(out distance);
return(true);
}
distance = 0.0f;
return(false);
}
public static void FastIntersectAxisAlignedBoxPlane(XMVector center, XMVector extents, XMVector plane, out XMVector outside, out XMVector inside)
{
// Compute the distance to the center of the box.
XMVector dist = XMVector4.Dot(center, plane);
// Project the axes of the box onto the normal of the plane. Half the
// length of the projection (sometime called the "radius") is equal to
// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// axes of the box. In this case b(i) = [(1,0,0), (0,1,0), (0,0,1)].
XMVector radius = XMVector3.Dot(extents, plane.Abs());
// Outside the plane?
outside = XMVector.Greater(dist, radius);
// Fully inside the plane?
inside = XMVector.Less(dist, -radius);
}
public static void FastIntersectAxisAlignedBoxPlane(XMVector center, XMVector extents, XMVector plane, out XMVector outside, out XMVector inside)
{
// Compute the distance to the center of the box.
XMVector dist = XMVector4.Dot(center, plane);
// Project the axes of the box onto the normal of the plane. Half the
// length of the projection (sometime called the "radius") is equal to
// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// axes of the box. In this case b(i) = [(1,0,0), (0,1,0), (0,0,1)].
XMVector radius = XMVector3.Dot(extents, plane.Abs());
// Outside the plane?
outside = XMVector.Greater(dist, radius);
// Fully inside the plane?
inside = XMVector.Less(dist, -radius);
}
public static bool XMPlaneIsUnit(XMVector plane)
{
XMVector difference = XMVector3.Length(plane) - XMVector.One;
return(XMVector4.Less(difference.Abs(), Internal.UnitPlaneEpsilon));
}
public static bool XMQuaternionIsUnit(XMVector q)
{
XMVector difference = XMVector4.Length(q) - XMVector.One;
return(XMVector4.Less(difference.Abs(), Internal.UnitQuaternionEpsilon));
}
public static bool XMVector3IsUnit(XMVector v)
{
XMVector difference = XMVector3.Length(v) - XMVector.One;
return(XMVector4.Less(difference.Abs(), Internal.UnitVectorEpsilon));
}
public static bool Intersects(XMVector a0, XMVector a1, XMVector a2, XMVector b0, XMVector b1, XMVector b2)
{
XMVector selectY = XMVector.FromInt((uint)XMSelection.Select0, (uint)XMSelection.Select1, (uint)XMSelection.Select0, (uint)XMSelection.Select0);
XMVector selectZ = XMVector.FromInt((uint)XMSelection.Select0, (uint)XMSelection.Select0, (uint)XMSelection.Select1, (uint)XMSelection.Select0);
XMVector select0111 = XMVector.FromInt((uint)XMSelection.Select0, (uint)XMSelection.Select1, (uint)XMSelection.Select1, (uint)XMSelection.Select1);
XMVector select1011 = XMVector.FromInt((uint)XMSelection.Select1, (uint)XMSelection.Select0, (uint)XMSelection.Select1, (uint)XMSelection.Select1);
XMVector select1101 = XMVector.FromInt((uint)XMSelection.Select1, (uint)XMSelection.Select1, (uint)XMSelection.Select0, (uint)XMSelection.Select1);
XMVector zero = XMGlobalConstants.Zero;
// Compute the normal of triangle A.
XMVector n1 = XMVector3.Cross(a1 - a0, a2 - a0);
// Assert that the triangle is not degenerate.
Debug.Assert(!XMVector3.Equal(n1, zero), "Reviewed");
// Test points of B against the plane of A.
XMVector b_dist = XMVector3.Dot(n1, b0 - a0);
b_dist = XMVector.Select(b_dist, XMVector3.Dot(n1, b1 - a0), selectY);
b_dist = XMVector.Select(b_dist, XMVector3.Dot(n1, b2 - a0), selectZ);
// Ensure robustness with co-planar triangles by zeroing small distances.
XMComparisonRecord b_distIsZeroCR;
XMVector b_distIsZero = XMVector.GreaterR(out b_distIsZeroCR, CollisionGlobalConstants.RayEpsilon, b_dist.Abs());
b_dist = XMVector.Select(b_dist, zero, b_distIsZero);
XMComparisonRecord b_distIsLessCR;
XMVector b_distIsLess = XMVector.GreaterR(out b_distIsLessCR, zero, b_dist);
XMComparisonRecord b_distIsGreaterCR;
XMVector b_distIsGreater = XMVector.GreaterR(out b_distIsGreaterCR, b_dist, zero);
// If all the points are on the same side we don't intersect.
if (b_distIsLessCR.IsAllTrue || b_distIsGreaterCR.IsAllTrue)
{
return(false);
}
// Compute the normal of triangle B.
XMVector n2 = XMVector3.Cross(b1 - b0, b2 - b0);
// Assert that the triangle is not degenerate.
Debug.Assert(!XMVector3.Equal(n2, zero), "Reviewed");
// Test points of A against the plane of B.
XMVector a_dist = XMVector3.Dot(n2, a0 - b0);
a_dist = XMVector.Select(a_dist, XMVector3.Dot(n2, a1 - b0), selectY);
a_dist = XMVector.Select(a_dist, XMVector3.Dot(n2, a2 - b0), selectZ);
// Ensure robustness with co-planar triangles by zeroing small distances.
XMComparisonRecord a_distIsZeroCR;
XMVector a_distIsZero = XMVector.GreaterR(out a_distIsZeroCR, CollisionGlobalConstants.RayEpsilon, b_dist.Abs());
a_dist = XMVector.Select(a_dist, zero, a_distIsZero);
XMComparisonRecord a_distIsLessCR;
XMVector a_distIsLess = XMVector.GreaterR(out a_distIsLessCR, zero, a_dist);
XMComparisonRecord a_distIsGreaterCR;
XMVector a_distIsGreater = XMVector.GreaterR(out a_distIsGreaterCR, a_dist, zero);
// If all the points are on the same side we don't intersect.
if (a_distIsLessCR.IsAllTrue || a_distIsGreaterCR.IsAllTrue)
{
return(false);
}
// Special case for co-planar triangles.
if (a_distIsZeroCR.IsAllTrue || b_distIsZeroCR.IsAllTrue)
{
XMVector axis, dist, minDist;
// Compute an axis perpindicular to the edge (points out).
axis = XMVector3.Cross(n1, a1 - a0);
dist = XMVector3.Dot(axis, a0);
// Test points of B against the axis.
minDist = XMVector3.Dot(b0, axis);
minDist = XMVector.Min(minDist, XMVector3.Dot(b1, axis));
minDist = XMVector.Min(minDist, XMVector3.Dot(b2, axis));
if (XMVector4.GreaterOrEqual(minDist, dist))
{
return(false);
}
// Edge (A1, A2)
axis = XMVector3.Cross(n1, a2 - a1);
dist = XMVector3.Dot(axis, a1);
minDist = XMVector3.Dot(b0, axis);
minDist = XMVector.Min(minDist, XMVector3.Dot(b1, axis));
minDist = XMVector.Min(minDist, XMVector3.Dot(b2, axis));
if (XMVector4.GreaterOrEqual(minDist, dist))
{
return(false);
}
// Edge (A2, A0)
axis = XMVector3.Cross(n1, a0 - a2);
dist = XMVector3.Dot(axis, a2);
minDist = XMVector3.Dot(b0, axis);
minDist = XMVector.Min(minDist, XMVector3.Dot(b1, axis));
minDist = XMVector.Min(minDist, XMVector3.Dot(b2, axis));
if (XMVector4.GreaterOrEqual(minDist, dist))
{
return(false);
}
// Edge (B0, B1)
axis = XMVector3.Cross(n2, b1 - b0);
dist = XMVector3.Dot(axis, b0);
minDist = XMVector3.Dot(a0, axis);
minDist = XMVector.Min(minDist, XMVector3.Dot(a1, axis));
minDist = XMVector.Min(minDist, XMVector3.Dot(a2, axis));
if (XMVector4.GreaterOrEqual(minDist, dist))
{
return(false);
}
// Edge (B1, B2)
axis = XMVector3.Cross(n2, b2 - b1);
dist = XMVector3.Dot(axis, b1);
minDist = XMVector3.Dot(a0, axis);
minDist = XMVector.Min(minDist, XMVector3.Dot(a1, axis));
minDist = XMVector.Min(minDist, XMVector3.Dot(a2, axis));
if (XMVector4.GreaterOrEqual(minDist, dist))
{
return(false);
}
// Edge (B2,B0)
axis = XMVector3.Cross(n2, b0 - b2);
dist = XMVector3.Dot(axis, b2);
minDist = XMVector3.Dot(a0, axis);
minDist = XMVector.Min(minDist, XMVector3.Dot(a1, axis));
minDist = XMVector.Min(minDist, XMVector3.Dot(a2, axis));
if (XMVector4.GreaterOrEqual(minDist, dist))
{
return(false);
}
return(true);
}
//// Find the single vertex of A and B (ie the vertex on the opposite side
//// of the plane from the other two) and reorder the edges so we can compute
//// the signed edge/edge distances.
////
//// if ( (V0 >= 0 && V1 < 0 && V2 < 0) ||
//// (V0 > 0 && V1 <= 0 && V2 <= 0) ||
//// (V0 <= 0 && V1 > 0 && V2 > 0) ||
//// (V0 < 0 && V1 >= 0 && V2 >= 0) ) then V0 is singular;
////
//// If our singular vertex is not on the positive side of the plane we reverse
//// the triangle winding so that the overlap comparisons will compare the
//// correct edges with the correct signs.
XMVector a_distIsLessEqual = XMVector.OrInt(a_distIsLess, a_distIsZero);
XMVector a_distIsGreaterEqual = XMVector.OrInt(a_distIsGreater, a_distIsZero);
XMVector aa0, aa1, aa2;
bool b_positiveA;
if (Internal.XMVector3AllTrue(XMVector.Select(a_distIsGreaterEqual, a_distIsLess, select0111)) ||
Internal.XMVector3AllTrue(XMVector.Select(a_distIsGreater, a_distIsLessEqual, select0111)))
{
// A0 is singular, crossing from positive to negative.
aa0 = a0;
aa1 = a1;
aa2 = a2;
b_positiveA = true;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(a_distIsLessEqual, a_distIsGreater, select0111)) ||
Internal.XMVector3AllTrue(XMVector.Select(a_distIsLess, a_distIsGreaterEqual, select0111)))
{
// A0 is singular, crossing from negative to positive.
aa0 = a0;
aa1 = a2;
aa2 = a1;
b_positiveA = false;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(a_distIsGreaterEqual, a_distIsLess, select1011)) ||
Internal.XMVector3AllTrue(XMVector.Select(a_distIsGreater, a_distIsLessEqual, select1011)))
{
// A1 is singular, crossing from positive to negative.
aa0 = a1;
aa1 = a2;
aa2 = a0;
b_positiveA = true;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(a_distIsLessEqual, a_distIsGreater, select1011)) ||
Internal.XMVector3AllTrue(XMVector.Select(a_distIsLess, a_distIsGreaterEqual, select1011)))
{
// A1 is singular, crossing from negative to positive.
aa0 = a1;
aa1 = a0;
aa2 = a2;
b_positiveA = false;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(a_distIsGreaterEqual, a_distIsLess, select1101)) ||
Internal.XMVector3AllTrue(XMVector.Select(a_distIsGreater, a_distIsLessEqual, select1101)))
{
// A2 is singular, crossing from positive to negative.
aa0 = a2;
aa1 = a0;
aa2 = a1;
b_positiveA = true;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(a_distIsLessEqual, a_distIsGreater, select1101)) ||
Internal.XMVector3AllTrue(XMVector.Select(a_distIsLess, a_distIsGreaterEqual, select1101)))
{
// A2 is singular, crossing from negative to positive.
aa0 = a2;
aa1 = a1;
aa2 = a0;
b_positiveA = false;
}
else
{
Debug.Assert(false, "Reviewed");
return(false);
}
XMVector b_distIsLessEqual = XMVector.OrInt(b_distIsLess, b_distIsZero);
XMVector b_distIsGreaterEqual = XMVector.OrInt(b_distIsGreater, b_distIsZero);
XMVector bb0, bb1, bb2;
bool b_positiveB;
if (Internal.XMVector3AllTrue(XMVector.Select(b_distIsGreaterEqual, b_distIsLess, select0111)) ||
Internal.XMVector3AllTrue(XMVector.Select(b_distIsGreater, b_distIsLessEqual, select0111)))
{
// B0 is singular, crossing from positive to negative.
bb0 = b0;
bb1 = b1;
bb2 = b2;
b_positiveB = true;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(b_distIsLessEqual, b_distIsGreater, select0111)) ||
Internal.XMVector3AllTrue(XMVector.Select(b_distIsLess, b_distIsGreaterEqual, select0111)))
{
// B0 is singular, crossing from negative to positive.
bb0 = b0;
bb1 = b2;
bb2 = b1;
b_positiveB = false;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(b_distIsGreaterEqual, b_distIsLess, select1011)) ||
Internal.XMVector3AllTrue(XMVector.Select(b_distIsGreater, b_distIsLessEqual, select1011)))
{
// B1 is singular, crossing from positive to negative.
bb0 = b1;
bb1 = b2;
bb2 = b0;
b_positiveB = true;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(b_distIsLessEqual, b_distIsGreater, select1011)) ||
Internal.XMVector3AllTrue(XMVector.Select(b_distIsLess, b_distIsGreaterEqual, select1011)))
{
// B1 is singular, crossing from negative to positive.
bb0 = b1;
bb1 = b0;
bb2 = b2;
b_positiveB = false;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(b_distIsGreaterEqual, b_distIsLess, select1101)) ||
Internal.XMVector3AllTrue(XMVector.Select(b_distIsGreater, b_distIsLessEqual, select1101)))
{
// B2 is singular, crossing from positive to negative.
bb0 = b2;
bb1 = b0;
bb2 = b1;
b_positiveB = true;
}
else if (Internal.XMVector3AllTrue(XMVector.Select(b_distIsLessEqual, b_distIsGreater, select1101)) ||
Internal.XMVector3AllTrue(XMVector.Select(b_distIsLess, b_distIsGreaterEqual, select1101)))
{
// B2 is singular, crossing from negative to positive.
bb0 = b2;
bb1 = b1;
bb2 = b0;
b_positiveB = false;
}
else
{
Debug.Assert(false, "Reviewed");
return(false);
}
XMVector delta0, delta1;
// Reverse the direction of the test depending on whether the singular vertices are
// the same sign or different signs.
if (b_positiveA ^ b_positiveB)
{
delta0 = bb0 - aa0;
delta1 = aa0 - bb0;
}
else
{
delta0 = aa0 - bb0;
delta1 = bb0 - aa0;
}
// Check if the triangles overlap on the line of intersection between the
// planes of the two triangles by finding the signed line distances.
XMVector dist0 = XMVector3.Dot(delta0, XMVector3.Cross(bb2 - bb0, aa2 - aa0));
if (XMVector4.Greater(dist0, zero))
{
return(false);
}
XMVector dist1 = XMVector3.Dot(delta1, XMVector3.Cross(bb1 - bb0, aa1 - aa0));
if (XMVector4.Greater(dist1, zero))
{
return(false);
}
return(true);
}
public bool Intersects(XMVector v0, XMVector v1, XMVector v2)
{
XMVector zero = XMGlobalConstants.Zero;
// Load the box.
XMVector v_center = this.center;
XMVector v_extents = this.extents;
XMVector boxMin = v_center - v_extents;
XMVector boxMax = v_center + v_extents;
// Test the axes of the box (in effect test the AAB against the minimal AAB
// around the triangle).
XMVector triMin = XMVector.Min(XMVector.Min(v0, v1), v2);
XMVector triMax = XMVector.Max(XMVector.Max(v0, v1), v2);
// for each i in (x, y, z) if a_min(i) > b_max(i) or b_min(i) > a_max(i) then disjoint
XMVector disjoint = XMVector.OrInt(XMVector.Greater(triMin, boxMax), XMVector.Greater(boxMin, triMax));
if (Internal.XMVector3AnyTrue(disjoint))
{
return(false);
}
// Test the plane of the triangle.
XMVector normal = XMVector3.Cross(v1 - v0, v2 - v0);
XMVector dist = XMVector3.Dot(normal, v0);
// Assert that the triangle is not degenerate.
Debug.Assert(!XMVector3.Equal(normal, zero), "Reviewed");
// for each i in (x, y, z) if n(i) >= 0 then v_min(i)=b_min(i), v_max(i)=b_max(i)
// else v_min(i)=b_max(i), v_max(i)=b_min(i)
XMVector normalSelect = XMVector.Greater(normal, zero);
XMVector v_min = XMVector.Select(boxMax, boxMin, normalSelect);
XMVector v_max = XMVector.Select(boxMin, boxMax, normalSelect);
// if n dot v_min + d > 0 || n dot v_max + d < 0 then disjoint
XMVector minDist = XMVector3.Dot(v_min, normal);
XMVector maxDist = XMVector3.Dot(v_max, normal);
XMVector noIntersection = XMVector.Greater(minDist, dist);
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(maxDist, dist));
// Move the box center to zero to simplify the following tests.
XMVector tV0 = v0 - v_center;
XMVector tV1 = v1 - v_center;
XMVector tV2 = v2 - v_center;
// Test the edge/edge axes (3*3).
XMVector e0 = tV1 - tV0;
XMVector e1 = tV2 - tV1;
XMVector e2 = tV0 - tV2;
// Make w zero.
e0.W = zero.W;
e1.W = zero.W;
e2.W = zero.W;
XMVector axis;
XMVector p0, p1, p2;
XMVector min, max;
XMVector radius;
//// Axis == (1,0,0) x e0 = (0, -e0.z, e0.y)
axis = new XMVector(e1.W, -e0.Z, e1.Y, e1.X);
p0 = XMVector3.Dot(tV0, axis);
//// p1 = XMVector3Dot( V1, Axis ); // p1 = p0;
p2 = XMVector3.Dot(tV2, axis);
min = XMVector.Min(p0, p2);
max = XMVector.Max(p0, p2);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (1,0,0) x e1 = (0, -e1.z, e1.y)
axis = new XMVector(e1.W, -e1.Z, e1.Y, e1.X);
p0 = XMVector3.Dot(tV0, axis);
p1 = XMVector3.Dot(tV1, axis);
//// p2 = XMVector3Dot( V2, Axis ); // p2 = p1;
min = XMVector.Min(p0, p1);
max = XMVector.Max(p0, p1);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (1,0,0) x e2 = (0, -e2.z, e2.y)
axis = new XMVector(e2.W, -e2.Z, e2.Y, e2.X);
p0 = XMVector3.Dot(tV0, axis);
p1 = XMVector3.Dot(tV1, axis);
//// p2 = XMVector3Dot( V2, Axis ); // p2 = p0;
min = XMVector.Min(p0, p1);
max = XMVector.Max(p0, p1);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (0,1,0) x e0 = (e0.z, 0, -e0.x)
axis = new XMVector(e0.Z, e0.W, -e0.X, e0.Y);
p0 = XMVector3.Dot(tV0, axis);
//// p1 = XMVector3Dot( V1, Axis ); // p1 = p0;
p2 = XMVector3.Dot(tV2, axis);
min = XMVector.Min(p0, p2);
max = XMVector.Max(p0, p2);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (0,1,0) x e1 = (e1.z, 0, -e1.x)
axis = new XMVector(e1.Z, e1.W, -e1.X, e1.Y);
p0 = XMVector3.Dot(tV0, axis);
p1 = XMVector3.Dot(tV1, axis);
//// p2 = XMVector3Dot( V2, Axis ); // p2 = p1;
min = XMVector.Min(p0, p1);
max = XMVector.Max(p0, p1);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (0,0,1) x e2 = (e2.z, 0, -e2.x)
axis = new XMVector(e2.Z, e2.W, -e2.X, e2.Y);
p0 = XMVector3.Dot(tV0, axis);
p1 = XMVector3.Dot(tV1, axis);
//// p2 = XMVector3Dot( V2, Axis ); // p2 = p0;
min = XMVector.Min(p0, p1);
max = XMVector.Max(p0, p1);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (0,0,1) x e0 = (-e0.y, e0.x, 0)
axis = new XMVector(-e0.Y, e0.X, e0.W, e0.Z);
p0 = XMVector3.Dot(tV0, axis);
//// p1 = XMVector3Dot( V1, Axis ); // p1 = p0;
p2 = XMVector3.Dot(tV2, axis);
min = XMVector.Min(p0, p2);
max = XMVector.Max(p0, p2);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (0,0,1) x e1 = (-e1.y, e1.x, 0)
axis = new XMVector(-e1.Y, e1.X, e1.W, e1.Z);
p0 = XMVector3.Dot(tV0, axis);
p1 = XMVector3.Dot(tV1, axis);
//// p2 = XMVector3Dot( V2, Axis ); // p2 = p1;
min = XMVector.Min(p0, p1);
max = XMVector.Max(p0, p1);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
//// Axis == (0,0,1) x e2 = (-e2.y, e2.x, 0)
axis = new XMVector(-e2.Y, e2.X, e2.W, e2.Z);
p0 = XMVector3.Dot(tV0, axis);
p1 = XMVector3.Dot(tV1, axis);
//// p2 = XMVector3Dot( V2, Axis ); // p2 = p0;
min = XMVector.Min(p0, p1);
max = XMVector.Max(p0, p1);
radius = XMVector3.Dot(v_extents, axis.Abs());
noIntersection = XMVector.OrInt(noIntersection, XMVector.Greater(min, radius));
noIntersection = XMVector.OrInt(noIntersection, XMVector.Less(max, -radius));
return(XMVector4.NotEqualInt(noIntersection, XMVector.TrueInt));
}