Added Stan Melax Convex Hull utility under Zlib license, Thanks Stan!

Use this Convex Hull to create a renderable shape, using btHullShape, Thanks to John McCutchan

Demos/BspDemo/main.cpp

@@ -17,6 +17,7 @@ subject to the following restrictions:
 #include "BspDemo.h"
 #include "GlutStuff.h"
 #include "GLDebugDrawer.h"
+#include "btBulletDynamicsCommon.h"
 
 char* makeExeToBspFilename(const char* lpCmdLine);
 char* getLastFileName();
@@ -44,9 +45,13 @@ int main(int argc,char** argv)
 		bspfilename = argv[1];
 	}
 
+	GLDebugDrawer	gDebugDrawer;
+
 	// Enrico: TODO: Should change parameter type of initPhysics() to std::string or at least const char *
 	bspDemo->initPhysics((char*)bspfilename);
 	
+	bspDemo->getDynamicsWorld()->setDebugDrawer(&gDebugDrawer);
+
 	
 
 	return glutmain(argc, argv,640,480,"Bullet Quake BSP Physics Viewer http://bullet.sourceforge.net",bspDemo);

Demos/OpenGL/GL_ShapeDrawer.cpp

@@ -39,7 +39,10 @@ subject to the following restrictions:
 #include "BulletCollision/CollisionShapes/btCapsuleShape.h"
 #include "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h"
 #include "BulletCollision/CollisionShapes/btUniformScalingShape.h"
+#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
+#include "BulletCollision/CollisionShapes/btShapeHull.h"
 
+#include "LinearMath/btTransformUtil.h"
 
 
 #include "LinearMath/btIDebugDraw.h"
@@ -302,12 +305,19 @@ void GL_ShapeDrawer::drawCylinder(float radius,float halfHeight, int upAxis)
 	gluQuadricDrawStyle(quadObj, (GLenum)GLU_FILL);
 	gluQuadricNormals(quadObj, (GLenum)GLU_SMOOTH);
 	
+	gluDisk(quadObj,0,radius,15, 10);
 	
 	gluCylinder(quadObj, radius, radius, 2.f*halfHeight, 15, 10);
+	glTranslatef(0.0, 0.0, 2.*halfHeight);
+	glRotatef(-180.0, 0.0, 1.0, 0.0);
+	gluDisk(quadObj,0,radius,15, 10);
+
 	glPopMatrix();
 	gluDeleteQuadric(quadObj);
 }
 
+
+
 void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, const btVector3& color,int	debugMode)
 {
 
@@ -358,6 +368,8 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 
 		if (!(debugMode & btIDebugDraw::DBG_DrawWireframe))
 		{
+			///you can comment out any of the specific cases, and use the default
+			///the benefit of 'default' is that it approximates the actual collision shape including collision margin
 			switch (shape->getShapeType())
 			{
 			case BOX_SHAPE_PROXYTYPE:
@@ -369,15 +381,8 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					useWireframeFallback = false;
 					break;
 				}
-			case TRIANGLE_SHAPE_PROXYTYPE:
+		
-			case TETRAHEDRAL_SHAPE_PROXYTYPE:
+			
-				{
-					//todo:	
-//					useWireframeFallback = false;
-					break;
-				}
-			case CONVEX_HULL_SHAPE_PROXYTYPE:
-				break;
 			case SPHERE_SHAPE_PROXYTYPE:
 				{
 					const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
@@ -386,29 +391,7 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					useWireframeFallback = false;
 					break;
 				}
-			case CAPSULE_SHAPE_PROXYTYPE:
-			{
-				const btCapsuleShape* capsuleShape = static_cast<const btCapsuleShape*>(shape);
-				float radius = capsuleShape->getRadius();
-				float halfHeight = capsuleShape->getHalfHeight();
-				int upAxis = 1;
 			
-				drawCylinder(radius,halfHeight,upAxis);
-
-				
-				glPushMatrix();
-				glTranslatef(0.0, -halfHeight,0.0);
-				glutSolidSphere(radius,10,10);
-				glTranslatef(0.0, 2*halfHeight,0.0);
-				glutSolidSphere(radius,10,10);
-				glPopMatrix();
-				useWireframeFallback = false;
-				break;
-			}
-			case MULTI_SPHERE_SHAPE_PROXYTYPE:
-				{
-					break;
-				}
 			case CONE_SHAPE_PROXYTYPE:
 				{
 					const btConeShape* coneShape = static_cast<const btConeShape*>(shape);
@@ -436,13 +419,33 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 					break;
 
 				}
-			case CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE:
+		
+
+			case STATIC_PLANE_PROXYTYPE:
 				{
-					useWireframeFallback = false;
+					const btStaticPlaneShape* staticPlaneShape = static_cast<const btStaticPlaneShape*>(shape);
+					btScalar planeConst = staticPlaneShape->getPlaneConstant();
+					const btVector3& planeNormal = staticPlaneShape->getPlaneNormal();
+					btVector3 planeOrigin = planeNormal * planeConst;
+					btVector3 vec0,vec1;
+					btPlaneSpace1(planeNormal,vec0,vec1);
+					btScalar vecLen = 100.f;
+					btVector3 pt0 = planeOrigin + vec0*vecLen;
+					btVector3 pt1 = planeOrigin - vec0*vecLen;
+					btVector3 pt2 = planeOrigin + vec1*vecLen;
+					btVector3 pt3 = planeOrigin - vec1*vecLen;
+					glBegin(GL_LINES);
+					glVertex3f(pt0.getX(),pt0.getY(),pt0.getZ());
+					glVertex3f(pt1.getX(),pt1.getY(),pt1.getZ());
+					glVertex3f(pt2.getX(),pt2.getY(),pt2.getZ());
+					glVertex3f(pt3.getX(),pt3.getY(),pt3.getZ());
+					glEnd();
+
+					
 					break;
+
 				}
 
-			case CONVEX_SHAPE_PROXYTYPE:
 			case CYLINDER_SHAPE_PROXYTYPE:
 				{
 					const btCylinderShape* cylinder = static_cast<const btCylinderShape*>(shape);
@@ -456,48 +459,104 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 
 					break;
 				}
+			
 			default:
 				{
-				}
 					
-			};
+					
+					if (shape->isConvex())
+					{
+						btConvexShape* convexShape = (btConvexShape*)shape;
+						if (!shape->getUserPointer())
+						{
+							//create a hull approximation
+							btShapeHull* hull = new btShapeHull(convexShape);
+							btScalar margin = shape->getMargin();
+							hull->buildHull(margin);
+							convexShape->setUserPointer(hull);
+
+							
+							printf("numTriangles = %d\n", hull->numTriangles ());
+							printf("numIndices = %d\n", hull->numIndices ());
+							printf("numVertices = %d\n", hull->numVertices ());
+							
 
 						}
 						
 						
 
 
-		if (useWireframeFallback)
+						if (shape->getUserPointer())
 						{
-			/// for polyhedral shapes
+							//glutSolidCube(1.0);
-			if (shape->isPolyhedral())
+							btShapeHull* hull = (btShapeHull*)shape->getUserPointer();
+
+							
+							if (hull->numTriangles () > 0)
 							{
-				btPolyhedralConvexShape* polyshape = (btPolyhedralConvexShape*) shape;
+								int index = 0;
+								const unsigned int* idx = hull->getIndexPointer();
+								const btVector3* vtx = hull->getVertexPointer();
 								
+								glBegin (GL_TRIANGLES);
 
-				glBegin(GL_LINES);
+								for (int i = 0; i < hull->numTriangles (); i++)
-
-
-				int i;
-				for (i=0;i<polyshape->getNumEdges();i++)
 								{
-					btPoint3 a,b;
+									int i1 = index++;
-					polyshape->getEdge(i,a,b);
+									int i2 = index++;
+									int i3 = index++;
+									btAssert(i1 < hull->numIndices () &&
+										i2 < hull->numIndices () &&
+										i3 < hull->numIndices ());
 
-					glVertex3f(a.getX(),a.getY(),a.getZ());
+									int index1 = idx[i1];
-					glVertex3f(b.getX(),b.getY(),b.getZ());
+									int index2 = idx[i2];
+									int index3 = idx[i3];
+									btAssert(index1 < hull->numVertices () &&
+										index2 < hull->numVertices () &&
+										index3 < hull->numVertices ());
 
+									btVector3 v1 = vtx[index1];
+									btVector3 v2 = vtx[index2];
+									btVector3 v3 = vtx[index3];
+									btVector3 normal = (v3-v1).cross(v2-v1);
+									normal.normalize ();
+									
+									glNormal3f(normal.getX(),normal.getY(),normal.getZ());
+									glVertex3f (v1.x(), v1.y(), v1.z());
+									glVertex3f (v2.x(), v2.y(), v2.z());
+									glVertex3f (v3.x(), v3.y(), v3.z());
 									
 								}
 								glEnd ();
 						
+						}
+					} else
+					{
+//						printf("unhandled drawing\n");
+					}
+					
+
+				}
+			}
+		}
+
+		}
+		
+
+		
+
+		/// for polyhedral shapes
+		if (debugMode==btIDebugDraw::DBG_DrawFeaturesText && (shape->isPolyhedral()))
+		{
+			btPolyhedralConvexShape* polyshape = (btPolyhedralConvexShape*) shape;
 			
-				if (debugMode==btIDebugDraw::DBG_DrawFeaturesText)
 			{
 				glRasterPos3f(0.0,  0.0,  0.0);
 				//BMF_DrawString(BMF_GetFont(BMF_kHelvetica10),polyshape->getExtraDebugInfo());
 
 				glColor3f(1.f, 1.f, 1.f);
+				int i;
 				for (i=0;i<polyshape->getNumVertices();i++)
 				{
 					btPoint3 vtx;
@@ -523,8 +582,6 @@ void GL_ShapeDrawer::drawOpenGL(btScalar* m, const btCollisionShape* shape, cons
 				}
 			}
 				
-				
-			}
 		}
 
 

src/BulletCollision/CollisionShapes/btShapeHull.cpp

@@ -0,0 +1,156 @@
+/*
+btbtShapeHull implemented by John McCutchan.
+
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "btShapeHull.h"
+#include "LinearMath/btConvexHull.h"
+
+#define NUM_UNITSPHERE_POINTS 42
+
+static btVector3 btUnitSpherePoints[NUM_UNITSPHERE_POINTS+MAX_PREFERRED_PENETRATION_DIRECTIONS*2] = 
+{
+	btVector3(btScalar(0.000000) , btScalar(-0.000000),btScalar(-1.000000)),
+	btVector3(btScalar(0.723608) , btScalar(-0.525725),btScalar(-0.447219)),
+	btVector3(btScalar(-0.276388) , btScalar(-0.850649),btScalar(-0.447219)),
+	btVector3(btScalar(-0.894426) , btScalar(-0.000000),btScalar(-0.447216)),
+	btVector3(btScalar(-0.276388) , btScalar(0.850649),btScalar(-0.447220)),
+	btVector3(btScalar(0.723608) , btScalar(0.525725),btScalar(-0.447219)),
+	btVector3(btScalar(0.276388) , btScalar(-0.850649),btScalar(0.447220)),
+	btVector3(btScalar(-0.723608) , btScalar(-0.525725),btScalar(0.447219)),
+	btVector3(btScalar(-0.723608) , btScalar(0.525725),btScalar(0.447219)),
+	btVector3(btScalar(0.276388) , btScalar(0.850649),btScalar(0.447219)),
+	btVector3(btScalar(0.894426) , btScalar(0.000000),btScalar(0.447216)),
+	btVector3(btScalar(-0.000000) , btScalar(0.000000),btScalar(1.000000)),
+	btVector3(btScalar(0.425323) , btScalar(-0.309011),btScalar(-0.850654)),
+	btVector3(btScalar(-0.162456) , btScalar(-0.499995),btScalar(-0.850654)),
+	btVector3(btScalar(0.262869) , btScalar(-0.809012),btScalar(-0.525738)),
+	btVector3(btScalar(0.425323) , btScalar(0.309011),btScalar(-0.850654)),
+	btVector3(btScalar(0.850648) , btScalar(-0.000000),btScalar(-0.525736)),
+	btVector3(btScalar(-0.525730) , btScalar(-0.000000),btScalar(-0.850652)),
+	btVector3(btScalar(-0.688190) , btScalar(-0.499997),btScalar(-0.525736)),
+	btVector3(btScalar(-0.162456) , btScalar(0.499995),btScalar(-0.850654)),
+	btVector3(btScalar(-0.688190) , btScalar(0.499997),btScalar(-0.525736)),
+	btVector3(btScalar(0.262869) , btScalar(0.809012),btScalar(-0.525738)),
+	btVector3(btScalar(0.951058) , btScalar(0.309013),btScalar(0.000000)),
+	btVector3(btScalar(0.951058) , btScalar(-0.309013),btScalar(0.000000)),
+	btVector3(btScalar(0.587786) , btScalar(-0.809017),btScalar(0.000000)),
+	btVector3(btScalar(0.000000) , btScalar(-1.000000),btScalar(0.000000)),
+	btVector3(btScalar(-0.587786) , btScalar(-0.809017),btScalar(0.000000)),
+	btVector3(btScalar(-0.951058) , btScalar(-0.309013),btScalar(-0.000000)),
+	btVector3(btScalar(-0.951058) , btScalar(0.309013),btScalar(-0.000000)),
+	btVector3(btScalar(-0.587786) , btScalar(0.809017),btScalar(-0.000000)),
+	btVector3(btScalar(-0.000000) , btScalar(1.000000),btScalar(-0.000000)),
+	btVector3(btScalar(0.587786) , btScalar(0.809017),btScalar(-0.000000)),
+	btVector3(btScalar(0.688190) , btScalar(-0.499997),btScalar(0.525736)),
+	btVector3(btScalar(-0.262869) , btScalar(-0.809012),btScalar(0.525738)),
+	btVector3(btScalar(-0.850648) , btScalar(0.000000),btScalar(0.525736)),
+	btVector3(btScalar(-0.262869) , btScalar(0.809012),btScalar(0.525738)),
+	btVector3(btScalar(0.688190) , btScalar(0.499997),btScalar(0.525736)),
+	btVector3(btScalar(0.525730) , btScalar(0.000000),btScalar(0.850652)),
+	btVector3(btScalar(0.162456) , btScalar(-0.499995),btScalar(0.850654)),
+	btVector3(btScalar(-0.425323) , btScalar(-0.309011),btScalar(0.850654)),
+	btVector3(btScalar(-0.425323) , btScalar(0.309011),btScalar(0.850654)),
+	btVector3(btScalar(0.162456) , btScalar(0.499995),btScalar(0.850654))
+};
+
+btShapeHull::btShapeHull (const btConvexShape* shape)
+{
+	m_shape = shape;
+	m_vertices.clear ();
+	m_indices = NULL;
+	m_numIndices = 0;
+}
+
+btShapeHull::~btShapeHull ()
+{
+	if (m_indices)
+		delete [] m_indices;
+	m_vertices.clear ();
+}
+
+bool
+btShapeHull::buildHull (btScalar margin)
+{
+	int numSampleDirections = NUM_UNITSPHERE_POINTS;
+	{
+		int numPDA = m_shape->getNumPreferredPenetrationDirections();
+		if (numPDA)
+		{
+			for (int i=0;i<numPDA;i++)
+			{
+				btVector3 norm;
+				m_shape->getPreferredPenetrationDirection(i,norm);
+				btUnitSpherePoints[numSampleDirections] = norm;
+				numSampleDirections++;
+			}
+		}
+	}
+
+	btVector3 supportPoints[NUM_UNITSPHERE_POINTS+MAX_PREFERRED_PENETRATION_DIRECTIONS*2];
+	for (int i = 0; i < numSampleDirections; i++)
+	{
+		supportPoints[i] = m_shape->localGetSupportingVertex(btUnitSpherePoints[i]);
+	}
+
+	HullDesc hd;
+	hd.mFlags = QF_TRIANGLES;
+	hd.mVcount = numSampleDirections;
+	hd.mVertices = &supportPoints[0][0];
+	hd.mVertexStride = sizeof (btVector3);
+
+
+	HullLibrary hl;
+	HullResult hr;
+	if (hl.CreateConvexHull (hd, hr) == QE_FAIL)
+	{
+		return false;
+	}
+
+	m_vertices.resize (hr.mNumOutputVertices);
+	float* V = hr.mOutputVertices;
+	for (unsigned int i = 0; i < hr.mNumOutputVertices; i++)
+	{
+		btVector3 hp (V[0], V[1], V[2]);
+		V+=3;
+		m_vertices[i] = hp;
+	}
+	m_numIndices = hr.mNumIndices;
+	m_indices = new unsigned int [m_numIndices];
+	for (unsigned int i = 0; i < m_numIndices; i++)
+	{
+		m_indices[i] = hr.mIndices[i];
+	}
+	return true;
+}
+
+int
+btShapeHull::numTriangles () const
+{
+	return m_numIndices / 3;
+}
+
+int
+btShapeHull::numVertices () const
+{
+	return m_vertices.size ();
+}
+
+int
+btShapeHull::numIndices () const
+{
+	return m_numIndices;
+}
+

src/BulletCollision/CollisionShapes/btShapeHull.h

@@ -0,0 +1,54 @@
+/*
+btShapeHull implemented by John McCutchan.
+
+Bullet Continuous Collision Detection and Physics Library
+Copyright (c) 2003-2008 Erwin Coumans  http://continuousphysics.com/Bullet/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SHAPE_HULL_H
+#define _SHAPE_HULL_H
+
+#include "LinearMath/btAlignedObjectArray.h"
+#include "btConvexShape.h"
+
+
+///btShapeHull takes a btConvexShape, builds the convex hull using btConvexHull and provides triangle indices and vertices.
+class btShapeHull
+{
+public:
+	btShapeHull (const btConvexShape* shape);
+	~btShapeHull ();
+
+	bool buildHull (btScalar margin);
+
+	int numTriangles () const;
+	int numVertices () const;
+	int numIndices () const;
+
+	const btVector3* getVertexPointer() const
+	{
+		return &m_vertices[0];
+	}
+	const unsigned int* getIndexPointer() const
+	{
+		return m_indices;
+	}
+
+protected:
+	btAlignedObjectArray<btVector3> m_vertices;
+	unsigned int* m_indices;
+	unsigned int m_numIndices;
+	const btConvexShape* m_shape;
+};
+
+#endif //_SHAPE_HULL_H

src/LinearMath/CMakeLists.txt

@@ -17,6 +17,7 @@ ADD_LIBRARY(LibLinearMath
 		btMinMax.h
 		btQuaternion.h
 		btStackAlloc.h
+		btConvexHull.h
 		btGeometryUtil.h
 		btMotionState.h
 		btTransform.h
@@ -26,6 +27,7 @@ ADD_LIBRARY(LibLinearMath
 		btQuickprof.h
 		btTransformUtil.h
 		btQuickprof.cpp
+		btConvexHull.cpp
 		btGeometryUtil.cpp
 		btAlignedAllocator.cpp
 )

src/LinearMath/btConvexHull.h

@@ -0,0 +1,143 @@
+
+/*
+Stan Melax Convex Hull Computation
+Copyright (c) 2008 Stan Melax http://www.melax.com/
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose, 
+including commercial applications, and to alter it and redistribute it freely, 
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+
+///includes modifications/improvements by John Ratcliff, see BringOutYourDead below.
+
+#ifndef CD_HULL_H
+#define CD_HULL_H
+
+class HullResult
+{
+public:
+	HullResult(void)
+	{
+		mPolygons = true;
+		mNumOutputVertices = 0;
+		mOutputVertices = 0;
+		mNumFaces = 0;
+		mNumIndices = 0;
+		mIndices = 0;
+	}
+	bool                    mPolygons;                  // true if indices represents polygons, false indices are triangles
+	unsigned int            mNumOutputVertices;         // number of vertices in the output hull
+	float                  *mOutputVertices;            // array of vertices, 3 floats each x,y,z
+	unsigned int            mNumFaces;                  // the number of faces produced
+	unsigned int            mNumIndices;                // the total number of indices
+	unsigned int           *mIndices;                   // pointer to indices.
+
+// If triangles, then indices are array indexes into the vertex list.
+// If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc..
+};
+
+enum HullFlag
+{
+	QF_TRIANGLES         = (1<<0),             // report results as triangles, not polygons.
+	QF_REVERSE_ORDER     = (1<<1),             // reverse order of the triangle indices.
+	QF_SKIN_WIDTH        = (1<<2),             // extrude hull based on this skin width
+	QF_DEFAULT           = 0
+};
+
+
+class HullDesc
+{
+public:
+	HullDesc(void)
+	{
+		mFlags          = QF_DEFAULT;
+		mVcount         = 0;
+		mVertices       = 0;
+		mVertexStride   = sizeof(float)*3;
+		mNormalEpsilon  = 0.001f;
+		mMaxVertices		= 4096; // maximum number of points to be considered for a convex hull.
+		mMaxFaces				= 4096;
+		mSkinWidth			= 0.01f; // default is one centimeter
+	};
+
+	HullDesc(HullFlag flag,
+					 unsigned int vcount,
+					 const float *vertices,
+					 unsigned int stride)
+	{
+		mFlags          = flag;
+		mVcount         = vcount;
+		mVertices       = vertices;
+		mVertexStride   = stride;
+		mNormalEpsilon  = 0.001f;
+		mMaxVertices    = 4096;
+		mSkinWidth = 0.01f; // default is one centimeter
+	}
+
+	bool HasHullFlag(HullFlag flag) const
+	{
+		if ( mFlags & flag ) return true;
+		return false;
+	}
+
+	void SetHullFlag(HullFlag flag)
+	{
+		mFlags|=flag;
+	}
+
+	void ClearHullFlag(HullFlag flag)
+	{
+		mFlags&=~flag;
+	}
+
+	unsigned int      mFlags;           // flags to use when generating the convex hull.
+	unsigned int      mVcount;          // number of vertices in the input point cloud
+	const float      *mVertices;        // the array of vertices.
+	unsigned int      mVertexStride;    // the stride of each vertex, in bytes.
+	float             mNormalEpsilon;   // the epsilon for removing duplicates.  This is a normalized value, if normalized bit is on.
+	float             mSkinWidth;
+	unsigned int      mMaxVertices;               // maximum number of vertices to be considered for the hull!
+	unsigned int      mMaxFaces;
+};
+
+enum HullError
+{
+	QE_OK,            // success!
+	QE_FAIL           // failed.
+};
+
+class HullLibrary
+{
+public:
+
+	HullError CreateConvexHull(const HullDesc       &desc,           // describes the input request
+															HullResult           &result);        // contains the resulst
+
+	HullError ReleaseResult(HullResult &result); // release memory allocated for this result, we are done with it.
+
+private:
+
+	//BringOutYourDead (John Ratcliff): When you create a convex hull you hand it a large input set of vertices forming a 'point cloud'. 
+	//After the hull is generated it give you back a set of polygon faces which index the *original* point cloud.
+	//The thing is, often times, there are many 'dead vertices' in the point cloud that are on longer referenced by the hull.
+	//The routine 'BringOutYourDead' find only the referenced vertices, copies them to an new buffer, and re-indexes the hull so that it is a minimal representation.
+	void BringOutYourDead(const float *verts,unsigned int vcount, float *overts,unsigned int &ocount,unsigned int *indices,unsigned indexcount);
+
+	bool    CleanupVertices(unsigned int svcount,
+													const float *svertices,
+													unsigned int stride,
+													unsigned int &vcount,       // output number of vertices
+													float *vertices,                 // location to store the results.
+													float  normalepsilon,
+													float *scale);
+};
+
+
+#endif
+