private static CollisionShape ExtractBox_Old(SubMesh subMesh)
{
if (DoLog)
{
Log("");
Log(string.Format("Extracting box for submesh {0}", subMesh.Name));
}
MeshTriangle[] triangles = ExtractSubmeshTriangles(subMesh);
int count = triangles.Length;
Plane[] planesUnsorted = new Plane[6];
int planeCount = 0;
// Iterate through the triangles. For each triangle,
// determine the plane it belongs to, and find the plane
// in the array of planes, or if it's not found, add it.
for (int i = 0; i < count; i++)
{
MeshTriangle t = triangles[i];
bool found = false;
Plane p = new Plane(t.vertPos[0], t.vertPos[1], t.vertPos[2]);
NormalizePlane(ref p);
if (DoLog)
{
Log(string.Format(" {0} => plane {1}", t.ToString(), p.ToString()));
}
for (int j = 0; j < planeCount; j++)
{
Plane pj = planesUnsorted[j];
if (SamePlane(pj, p))
{
if (DoLog)
{
Log(string.Format(" plane {0} same as plane {1}", p.ToString(), pj.ToString()));
}
found = true;
break;
}
}
if (!found)
{
if (planeCount < 6)
{
if (DoLog)
{
Log(string.Format(" plane[{0}] = plane {1}", planeCount, p.ToString()));
}
planesUnsorted[planeCount++] = p;
}
else
{
Debug.Assert(false,
string.Format("In the definition of box {0}, more than 6 planes were found",
subMesh.Name));
}
}
}
Debug.Assert(planeCount == 6,
string.Format("In the definition of box {0}, fewer than 6 planes were found",
subMesh.Name));
// Now recreate the planes array, making sure that
// opposite faces are 3 planes apart
Plane[] planes = new Plane[6];
bool[] planeUsed = new bool[6];
for (int i = 0; i < 6; i++)
{
planeUsed[i] = false;
}
int planePair = 0;
for (int i = 0; i < 6; i++)
{
if (!planeUsed[i])
{
Plane p1 = planesUnsorted[i];
planes[planePair] = p1;
planeUsed[i] = true;
for (int j = 0; j < 6; j++)
{
Plane p2 = planesUnsorted[j];
if (!planeUsed[j] && !Orthogonal(p2, p1))
{
planes[3 + planePair++] = p2;
planeUsed[j] = true;
break;
}
}
}
}
Debug.Assert(planePair == 3, "Didn't find 3 pairs of parallel planes");
// Make sure that the sequence of planes follows the
// right-hand rule
if (planes[0].Normal.Cross(planes[1].Normal).Dot(planes[3].Normal) < 0)
{
// Swap the first two plane pairs
Plane p = planes[0];
planes[0] = planes[1];
planes[1] = p;
p = planes[0 + 3];
planes[0 + 3] = planes[1 + 3];
planes[1 + 3] = p;
Debug.Assert(planes[0].Normal.Cross(planes[1].Normal).Dot(planes[3].Normal) > 0,
"Even after swapping, planes don't obey the right-hand rule");
}
// Now we have our 6 planes, sorted so that opposite
// planes are 3 planes apart, and so they obey the
// right-hand rule. This guarantees that corners
// correspond. Find the 8 intersections that define the
// corners.
Vector3[] corners = new Vector3[8];
int cornerCount = 0;
for (int i = 0; i <= 3; i += 3)
{
Plane p1 = planes[i];
for (int j = 1; j <= 4; j += 3)
{
Plane p2 = planes[j];
for (int k = 2; k <= 5; k += 3)
{
Plane p3 = planes[k];
Vector3 corner = -1 * ((p1.D * (p2.Normal.Cross(p3.Normal)) +
p2.D * (p3.Normal.Cross(p1.Normal)) +
p3.D * (p1.Normal.Cross(p2.Normal))) /
p1.Normal.Dot(p2.Normal.Cross(p3.Normal)));
Debug.Assert(cornerCount < 8,
string.Format("In the definition of box {0}, more than 8 corners were found",
subMesh.Name));
if (DoLog)
{
Log(string.Format(" corner#{0}: {1}", cornerCount, corner.ToString()));
}
corners[cornerCount++] = corner;
}
}
}
Debug.Assert(cornerCount == 8,
string.Format("In the definition of box {0}, fewer than 8 corners were found",
subMesh.Name));
// We know that corners correspond. Now find the center
Vector3 center = (corners[0] + corners[7]) / 2;
Debug.Assert((center - (corners[1] + corners[5]) / 2.0f).Length > geometryEpsilon ||
(center - (corners[2] + corners[6]) / 2.0f).Length > geometryEpsilon ||
(center - (corners[3] + corners[7]) / 2.0f).Length > geometryEpsilon,
string.Format("In the definition of box {0}, center definition {0} is not consistent",
subMesh.Name, center.ToString()));
// Find the extents
Vector3 extents = new Vector3(Math.Abs((corners[1] - corners[0]).Length / 2.0f),
Math.Abs((corners[3] - corners[1]).Length / 2.0f),
Math.Abs((corners[4] - corners[0]).Length / 2.0f));
if (DoLog)
{
Log(string.Format(" extents {0}", extents.ToString()));
}
// Find the axes
Vector3[] axes = new Vector3[3] {
(corners[1] - corners[0]).ToNormalized(),
(corners[3] - corners[1]).ToNormalized(),
(corners[4] - corners[0]).ToNormalized()
};
if (DoLog)
{
for (int i = 0; i < 3; i++)
{
Log(string.Format(" axis[{0}] {1}", i, axes[i]));
}
}
// Now, is it an obb or an aabb? Figure out if the axes
// point in the same direction as the basis vectors, and
// if so, the order of the axes
int[] mapping = new int[3] {
-1, -1, -1
};
int foundMapping = 0;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (axes[i].Cross(Primitives.UnitBasisVectors[j]).Length < geometryEpsilon)
{
mapping[i] = j;
foundMapping++;
break;
}
}
}
CollisionShape shape;
if (foundMapping == 3)
{
// It's an AABB, so build the min and max vectors, in
// the order that matches the unit basis vector order
Vector3 min = Vector3.Zero;
Vector3 max = Vector3.Zero;
for (int i = 0; i < 3; i++)
{
float e = extents[i];
int j = mapping[i];
min[j] = center[j] - e;
max[j] = center[j] + e;
}
shape = new CollisionAABB(min, max);
}
else
{
Vector3 ruleTest = axes[0].Cross(axes[1]);
if (axes[2].Dot(ruleTest) < 0)
{
axes[2] = -1 * axes[2];
}
// Return the OBB
shape = new CollisionOBB(center, axes, extents);
}
if (DoLog)
{
Log(string.Format("Extraction result: {0}", shape));
}
return(shape);
}