From e0b28e6726254f8ac34d28021e58ce361b51442e Mon Sep 17 00:00:00 2001 From: ejcoumans Date: Fri, 26 May 2006 05:54:21 +0000 Subject: [PATCH] --- Extras/ConvexDecomposition/ConvexBuilder.cpp | 360 +++++++++++++++++++ Extras/ConvexDecomposition/ConvexBuilder.h | 110 ++++++ 2 files changed, 470 insertions(+) create mode 100644 Extras/ConvexDecomposition/ConvexBuilder.cpp create mode 100644 Extras/ConvexDecomposition/ConvexBuilder.h diff --git a/Extras/ConvexDecomposition/ConvexBuilder.cpp b/Extras/ConvexDecomposition/ConvexBuilder.cpp new file mode 100644 index 000000000..94b886e75 --- /dev/null +++ b/Extras/ConvexDecomposition/ConvexBuilder.cpp @@ -0,0 +1,360 @@ +#include "ConvexBuilder.h" +#include "meshvolume.h" +#include "bestfit.h" +#include +#include "cd_hull.h" +#include "float_math.h" +#include +#include "fitsphere.h" +#include "bestfitobb.h" + +CHull::CHull(const ConvexResult &result) +{ + mResult = new ConvexResult(result); + mVolume = computeMeshVolume( result.mHullVertices, result.mHullTcount, result.mHullIndices ); + + mDiagonal = getBoundingRegion( result.mHullVcount, result.mHullVertices, sizeof(float)*3, mMin, mMax ); + + float dx = mMax[0] - mMin[0]; + float dy = mMax[1] - mMin[1]; + float dz = mMax[2] - mMin[2]; + + dx*=0.1f; // inflate 1/10th on each edge + dy*=0.1f; // inflate 1/10th on each edge + dz*=0.1f; // inflate 1/10th on each edge + + mMin[0]-=dx; + mMin[1]-=dy; + mMin[2]-=dz; + + mMax[0]+=dx; + mMax[1]+=dy; + mMax[2]+=dz; + + +} + +CHull::~CHull(void) +{ + delete mResult; +} + +bool CHull::overlap(const CHull &h) const +{ + return overlapAABB(mMin,mMax, h.mMin, h.mMax ); +} + + + + +ConvexBuilder::ConvexBuilder(ConvexDecompInterface *callback) +{ + mCallback = callback; +}; + +ConvexBuilder::~ConvexBuilder(void) +{ + CHullVector::iterator i; + for (i=mChulls.begin(); i!=mChulls.end(); ++i) + { + CHull *cr = (*i); + delete cr; + } +} + +bool ConvexBuilder::isDuplicate(unsigned int i1,unsigned int i2,unsigned int i3, + unsigned int ci1,unsigned int ci2,unsigned int ci3) +{ + unsigned int dcount = 0; + + assert( i1 != i2 && i1 != i3 && i2 != i3 ); + assert( ci1 != ci2 && ci1 != ci3 && ci2 != ci3 ); + + if ( i1 == ci1 || i1 == ci2 || i1 == ci3 ) dcount++; + if ( i2 == ci1 || i2 == ci2 || i2 == ci3 ) dcount++; + if ( i3 == ci1 || i3 == ci2 || i3 == ci3 ) dcount++; + + return dcount == 3; +} + +void ConvexBuilder::getMesh(const ConvexResult &cr,VertexLookup vc,UintVector &indices) +{ + unsigned int *src = cr.mHullIndices; + + for (unsigned int i=0; ioverlap(*b) ) return 0; // if their AABB's (with a little slop) don't overlap, then return. + + CHull *ret = 0; + + // ok..we are going to combine both meshes into a single mesh + // and then we are going to compute the concavity... + + VertexLookup vc = Vl_createVertexLookup(); + + UintVector indices; + + getMesh( *a->mResult, vc, indices ); + getMesh( *b->mResult, vc, indices ); + + unsigned int vcount = Vl_getVcount(vc); + const float *vertices = Vl_getVertices(vc); + unsigned int tcount = indices.size()/3; + unsigned int *idx = &indices[0]; + + HullResult hresult; + HullLibrary hl; + HullDesc desc; + + desc.SetHullFlag(QF_TRIANGLES); + + desc.mVcount = vcount; + desc.mVertices = vertices; + desc.mVertexStride = sizeof(float)*3; + + HullError hret = hl.CreateConvexHull(desc,hresult); + + if ( hret == QE_OK ) + { + + float combineVolume = computeMeshVolume( hresult.mOutputVertices, hresult.mNumFaces, hresult.mIndices ); + float sumVolume = a->mVolume + b->mVolume; + + float percent = (sumVolume*100) / combineVolume; + if ( percent >= (100.0f-MERGE_PERCENT) ) + { + ConvexResult cr(hresult.mNumOutputVertices, hresult.mOutputVertices, hresult.mNumFaces, hresult.mIndices); + ret = new CHull(cr); + } + } + + + Vl_releaseVertexLookup(vc); + + return ret; +} + +bool ConvexBuilder::combineHulls(void) +{ + + bool combine = false; + + sortChulls(mChulls); // sort the convex hulls, largest volume to least... + + CHullVector output; // the output hulls... + + + CHullVector::iterator i; + + for (i=mChulls.begin(); i!=mChulls.end() && !combine; ++i) + { + CHull *cr = (*i); + + CHullVector::iterator j; + for (j=mChulls.begin(); j!=mChulls.end(); ++j) + { + CHull *match = (*j); + + if ( cr != match ) // don't try to merge a hull with itself, that be stoopid + { + + CHull *merge = canMerge(cr,match); // if we can merge these two.... + + if ( merge ) + { + + output.push_back(merge); + + + ++i; + while ( i != mChulls.end() ) + { + CHull *cr = (*i); + if ( cr != match ) + { + output.push_back(cr); + } + i++; + } + + delete cr; + delete match; + combine = true; + break; + } + } + } + + if ( combine ) + { + break; + } + else + { + output.push_back(cr); + } + + } + + if ( combine ) + { + mChulls.clear(); + mChulls = output; + output.clear(); + } + + + return combine; +} + +unsigned int ConvexBuilder::process(const DecompDesc &desc) +{ + + unsigned int ret = 0; + + MAXDEPTH = desc.mDepth; + CONCAVE_PERCENT = desc.mCpercent; + MERGE_PERCENT = desc.mPpercent; + + + calcConvexDecomposition(desc.mVcount, desc.mVertices, desc.mTcount, desc.mIndices,this,0,0); + + + while ( combineHulls() ); // keep combinging hulls until I can't combine any more... + + CHullVector::iterator i; + for (i=mChulls.begin(); i!=mChulls.end(); ++i) + { + CHull *cr = (*i); + + // before we hand it back to the application, we need to regenerate the hull based on the + // limits given by the user. + + const ConvexResult &c = *cr->mResult; // the high resolution hull... + + HullResult result; + HullLibrary hl; + HullDesc hdesc; + + hdesc.SetHullFlag(QF_TRIANGLES); + + hdesc.mVcount = c.mHullVcount; + hdesc.mVertices = c.mHullVertices; + hdesc.mVertexStride = sizeof(float)*3; + hdesc.mMaxVertices = desc.mMaxVertices; // maximum number of vertices allowed in the output + + if ( desc.mSkinWidth > 0 ) + { + hdesc.mSkinWidth = desc.mSkinWidth; + hdesc.SetHullFlag(QF_SKIN_WIDTH); // do skin width computation. + } + + HullError ret = hl.CreateConvexHull(hdesc,result); + + if ( ret == QE_OK ) + { + ConvexResult r(result.mNumOutputVertices, result.mOutputVertices, result.mNumFaces, result.mIndices); + + r.mHullVolume = computeMeshVolume( result.mOutputVertices, result.mNumFaces, result.mIndices ); // the volume of the hull. + + // compute the best fit OBB + computeBestFitOBB( result.mNumOutputVertices, result.mOutputVertices, sizeof(float)*3, r.mOBBSides, r.mOBBTransform ); + + r.mOBBVolume = r.mOBBSides[0] * r.mOBBSides[1] *r.mOBBSides[2]; // compute the OBB volume. + + fm_getTranslation( r.mOBBTransform, r.mOBBCenter ); // get the translation component of the 4x4 matrix. + + fm_matrixToQuat( r.mOBBTransform, r.mOBBOrientation ); // extract the orientation as a quaternion. + + r.mSphereRadius = computeBoundingSphere( result.mNumOutputVertices, result.mOutputVertices, r.mSphereCenter ); + r.mSphereVolume = fm_sphereVolume( r.mSphereRadius ); + + + mCallback->ConvexDecompResult(r); + } + + + delete cr; + } + + ret = mChulls.size(); + + mChulls.clear(); + + return ret; +} + + +void ConvexBuilder::ConvexDebugTri(const float *p1,const float *p2,const float *p3,unsigned int color) +{ + mCallback->ConvexDebugTri(p1,p2,p3,color); +} + +void ConvexBuilder::ConvexDebugOBB(const float *sides, const float *matrix,unsigned int color) +{ + mCallback->ConvexDebugOBB(sides,matrix,color); +} +void ConvexBuilder::ConvexDebugPoint(const float *p,float dist,unsigned int color) +{ + mCallback->ConvexDebugPoint(p,dist,color); +} + +void ConvexBuilder::ConvexDebugBound(const float *bmin,const float *bmax,unsigned int color) +{ + mCallback->ConvexDebugBound(bmin,bmax,color); +} + +void ConvexBuilder::ConvexDecompResult(ConvexResult &result) +{ + CHull *ch = new CHull(result); + mChulls.push_back(ch); +} + +void ConvexBuilder::sortChulls(CHullVector &hulls) +{ + std::sort( hulls.begin(), hulls.end(), CHullSort() ); +} + + diff --git a/Extras/ConvexDecomposition/ConvexBuilder.h b/Extras/ConvexDecomposition/ConvexBuilder.h new file mode 100644 index 000000000..6b1321b6a --- /dev/null +++ b/Extras/ConvexDecomposition/ConvexBuilder.h @@ -0,0 +1,110 @@ +#ifndef CONVEX_BUILDER_H +#define CONVEX_BUILDER_H + +/*---------------------------------------------------------------------- +Copyright (c) 2004 Open Dynamics Framework Group +www.physicstools.org +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided +that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list of conditions +and the following disclaimer. + +Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +Neither the name of the Open Dynamics Framework Group nor the names of its contributors may +be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +-----------------------------------------------------------------------*/ + +// http://codesuppository.blogspot.com +// +// mailto: jratcliff@infiniplex.net +// +// http://www.amillionpixels.us +// + + +#include "convexdecomposition.h" +#include "vlookup.h" + +using namespace ConvexDecomposition; + + +class CHull +{ +public: + CHull(const ConvexResult &result); + + ~CHull(void); + + bool overlap(const CHull &h) const; + + float mMin[3]; + float mMax[3]; + float mVolume; + float mDiagonal; // long edge.. + ConvexResult *mResult; +}; + +// Usage: std::sort( list.begin(), list.end(), StringSortRef() ); +class CHullSort +{ +public: + + inline bool operator()(const CHull *a,const CHull *b) const + { + return a->mVolume < b->mVolume; + } +}; + + +typedef std::vector< CHull * > CHullVector; + + + +class ConvexBuilder : public ConvexDecompInterface +{ +public: + ConvexBuilder(ConvexDecompInterface *callback); + + ~ConvexBuilder(void); + + bool isDuplicate(unsigned int i1,unsigned int i2,unsigned int i3, + unsigned int ci1,unsigned int ci2,unsigned int ci3); + + void getMesh(const ConvexResult &cr,VertexLookup vc,UintVector &indices); + + CHull * canMerge(CHull *a,CHull *b); + + bool combineHulls(void); + + unsigned int process(const DecompDesc &desc); + + virtual void ConvexDebugTri(const float *p1,const float *p2,const float *p3,unsigned int color); + + virtual void ConvexDebugOBB(const float *sides, const float *matrix,unsigned int color); + virtual void ConvexDebugPoint(const float *p,float dist,unsigned int color); + + virtual void ConvexDebugBound(const float *bmin,const float *bmax,unsigned int color); + + virtual void ConvexDecompResult(ConvexResult &result); + + void sortChulls(CHullVector &hulls); + + CHullVector mChulls; + ConvexDecompInterface *mCallback; +}; + +#endif //CONVEX_BUILDER_H \ No newline at end of file