ConvexDecomposition.h

Go to the documentation of this file.

#ifndef CONVEX_DECOMPOSITION_H
 
#define CONVEX_DECOMPOSITION_H
 
namespace ConvexDecomposition
{
 
class ConvexResult
{
public:
  ConvexResult(void)
  {
    mHullVcount = 0;
    mHullVertices = 0;
    mHullTcount = 0;
    mHullIndices = 0;
  }
 
  ConvexResult(unsigned int hvcount,const double *hvertices,unsigned int htcount,const unsigned int *hindices)
  {
    mHullVcount = hvcount;
    if ( mHullVcount )
    {
      mHullVertices = new double[mHullVcount*sizeof(double)*3];
      memcpy(mHullVertices, hvertices, sizeof(double)*3*mHullVcount );
    }
    else
    {
      mHullVertices = 0;
    }
 
    mHullTcount = htcount;
 
    if ( mHullTcount )
    {
      mHullIndices = new unsigned int[sizeof(unsigned int)*mHullTcount*3];
      memcpy(mHullIndices,hindices, sizeof(unsigned int)*mHullTcount*3 );
    }
    else
    {
      mHullIndices = 0;
    }
 
  }
 
  ConvexResult(const ConvexResult &r) // copy constructor, perform a deep copy of the data.
  {
    mHullVcount = r.mHullVcount;
    if ( mHullVcount )
    {
      mHullVertices = new double[mHullVcount*sizeof(double)*3];
      memcpy(mHullVertices, r.mHullVertices, sizeof(double)*3*mHullVcount );
    }
    else
    {
      mHullVertices = 0;
    }
    mHullTcount = r.mHullTcount;
    if ( mHullTcount )
    {
      mHullIndices = new unsigned int[sizeof(unsigned int)*mHullTcount*3];
      memcpy(mHullIndices, r.mHullIndices, sizeof(unsigned int)*mHullTcount*3 );
    }
    else
    {
      mHullIndices = 0;
    }
  }
 
  ~ConvexResult(void)
  {
    delete mHullVertices;
    delete mHullIndices;
  }
 
// the convex hull.
  unsigned int              mHullVcount;
  double *                                                mHullVertices;
  unsigned  int       mHullTcount;
  unsigned int                   *mHullIndices;
 
  double               mHullVolume;                 // the volume of the convex hull.
 
};
 
// convert from doubles back down to floats.
class FConvexResult
{
public:
  FConvexResult(const ConvexResult &r)
  {
    mHullVcount = r.mHullVcount;
    mHullVertices = 0;
    if ( mHullVcount )
    {
      mHullVertices = new float[mHullVcount*3];
 
      const double *src = r.mHullVertices;
      float *     dest  = mHullVertices;
      for (unsigned int i=0; i<mHullVcount; i++)
      {
        dest[0] = (float) src[0];
        dest[1] = (float) src[1];
        dest[2] = (float) src[2];
        src+=3;
        dest+=3;
      }
    }
    mHullTcount = r.mHullTcount;
    if ( mHullTcount )
    {
      mHullIndices = new unsigned int[mHullTcount*3];
      memcpy(mHullIndices,r.mHullIndices,sizeof(unsigned int)*mHullTcount*3);
    }
    else
    {
      mHullIndices = 0;
    }
    mHullVolume = (float)r.mHullVolume;
  }
 
  ~FConvexResult(void)
  {
    delete mHullVertices;
    delete mHullIndices;
  }
 
  unsigned int              mHullVcount;
  float  *                                                mHullVertices;
  unsigned  int       mHullTcount;
  unsigned int                   *mHullIndices;
  float                mHullVolume;                 // the volume of the convex hull.
};
 
class ConvexDecompInterface
{
public:
 
        virtual void ConvexDebugTri(const double *p1,const double *p2,const double *p3,unsigned int color) { };
        virtual void ConvexDebugPoint(const double *p,double dist,unsigned int color) { };
  virtual void ConvexDebugBound(const double *bmin,const double *bmax,unsigned int color) { };
  virtual void ConvexDebugOBB(const double *sides, const double *matrix,unsigned int color) { };
 
  virtual void ConvexDecompResult(ConvexResult &result) = 0;
 
 
 
};
 
// just to avoid passing a zillion parameters to the method the
// options are packed into this descriptor.
class DecompDesc
{
public:
  DecompDesc(void)
  {
        mVcount = 0;
        mVertices = 0;
        mTcount   = 0;
        mIndices  = 0;
        mDepth    = 5;
        mCpercent = 5;
        mPpercent = 5;
        mMaxVertices = 32;
        mSkinWidth   = 0;
        mCallback    = 0;
  }
 
// describes the input triangle.
  unsigned      int     mVcount;   // the number of vertices in the source mesh.
  const double  *mVertices; // start of the vertex position array.  Assumes a stride of 3 doubles.
  unsigned int  mTcount;   // the number of triangles in the source mesh.
  unsigned int *mIndices;  // the indexed triangle list array (zero index based)
 
// options
  unsigned int  mDepth;    // depth to split, a maximum of 10, generally not over 7.
  double         mCpercent; // the concavity threshold percentage.  0=20 is reasonable.
        double         mPpercent; // the percentage volume conservation threshold to collapse hulls. 0-30 is reasonable.
 
// hull output limits.
  unsigned int  mMaxVertices; // maximum number of vertices in the output hull. Recommended 32 or less.
  double         mSkinWidth;   // a skin width to apply to the output hulls.
 
        ConvexDecompInterface *mCallback; // the interface to receive back the results.
 
};
 
// perform approximate convex decomposition on a mesh.
unsigned int performConvexDecomposition(const DecompDesc &desc); // returns the number of hulls produced.
 
};
 
#endif