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 * ConvexBuilder::canMerge(CHull *a,CHull *b) { if ( !a->overlap(*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; //don't do anything if hull is empty if (!tcount) { Vl_releaseVertexLookup (vc); return 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; }
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... int i; for (i=0;i<mChulls.size();i++) { CHull *cr = mChulls[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 ) { 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); } hl.ReleaseResult (result); delete cr; } ret = mChulls.size(); mChulls.clear(); return ret; }
float getVolume(ConvexDecompInterface *callback) const { unsigned int indices[8*3]; unsigned int tcount = 0; addTri(indices,0,1,2,tcount); addTri(indices,3,4,5,tcount); addTri(indices,0,3,4,tcount); addTri(indices,0,4,1,tcount); addTri(indices,1,4,5,tcount); addTri(indices,1,5,2,tcount); addTri(indices,0,3,5,tcount); addTri(indices,0,5,2,tcount); const float *vertices = mP1.Ptr(); if ( callback ) { unsigned int color = getDebugColor(); #if 0 Vector3d d1 = mNear1; Vector3d d2 = mNear2; Vector3d d3 = mNear3; callback->ConvexDebugPoint(mP1.Ptr(),0.01f,0x00FF00); callback->ConvexDebugPoint(mP2.Ptr(),0.01f,0x00FF00); callback->ConvexDebugPoint(mP3.Ptr(),0.01f,0x00FF00); callback->ConvexDebugPoint(d1.Ptr(),0.01f,0xFF0000); callback->ConvexDebugPoint(d2.Ptr(),0.01f,0xFF0000); callback->ConvexDebugPoint(d3.Ptr(),0.01f,0xFF0000); callback->ConvexDebugTri(mP1.Ptr(), d1.Ptr(), d1.Ptr(),0x00FF00); callback->ConvexDebugTri(mP2.Ptr(), d2.Ptr(), d2.Ptr(),0x00FF00); callback->ConvexDebugTri(mP3.Ptr(), d3.Ptr(), d3.Ptr(),0x00FF00); #else for (unsigned int i=0; i<tcount; i++) { unsigned int i1 = indices[i*3+0]; unsigned int i2 = indices[i*3+1]; unsigned int i3 = indices[i*3+2]; const float *p1 = &vertices[ i1*3 ]; const float *p2 = &vertices[ i2*3 ]; const float *p3 = &vertices[ i3*3 ]; callback->ConvexDebugTri(p1,p2,p3,color); } #endif } float v = computeMeshVolume(mP1.Ptr(), tcount, indices ); return v; }