mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-07-12 15:14:35 +00:00
Engine directory for ticket #1
This commit is contained in:
DavidWyand-GG
parent
352279af7a
commit
7dbfe6994d
3795 changed files with 1363358 additions and 0 deletions
788
Engine/lib/convexDecomp/NvConvexDecomposition.cpp
Normal file
788
Engine/lib/convexDecomp/NvConvexDecomposition.cpp
Normal file
|
|
@ -0,0 +1,788 @@
|
|||
|
||||
/*
|
||||
|
||||
NvConvexDecomposition.cpp : The main interface to the convex decomposition library.
|
||||
|
||||
*/
|
||||
|
||||
/*!
|
||||
**
|
||||
** Copyright (c) 2009 by John W. Ratcliff mailto:jratcliffscarab@gmail.com
|
||||
**
|
||||
** Portions of this source has been released with the PhysXViewer application, as well as
|
||||
** Rocket, CreateDynamics, ODF, and as a number of sample code snippets.
|
||||
**
|
||||
** If you find this code useful or you are feeling particularily generous I would
|
||||
** ask that you please go to http://www.amillionpixels.us and make a donation
|
||||
** to Troy DeMolay.
|
||||
**
|
||||
** DeMolay is a youth group for young men between the ages of 12 and 21.
|
||||
** It teaches strong moral principles, as well as leadership skills and
|
||||
** public speaking. The donations page uses the 'pay for pixels' paradigm
|
||||
** where, in this case, a pixel is only a single penny. Donations can be
|
||||
** made for as small as $4 or as high as a $100 block. Each person who donates
|
||||
** will get a link to their own site as well as acknowledgement on the
|
||||
** donations blog located here http://www.amillionpixels.blogspot.com/
|
||||
**
|
||||
** If you wish to contact me you can use the following methods:
|
||||
**
|
||||
** Skype ID: jratcliff63367
|
||||
** Yahoo: jratcliff63367
|
||||
** AOL: jratcliff1961
|
||||
** email: jratcliffscarab@gmail.com
|
||||
**
|
||||
**
|
||||
** The MIT license:
|
||||
**
|
||||
** Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
** of this software and associated documentation files (the "Software"), to deal
|
||||
** in the Software without restriction, including without limitation the rights
|
||||
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
** copies of the Software, and to permit persons to whom the Software is furnished
|
||||
** to do so, subject to the following conditions:
|
||||
**
|
||||
** The above copyright notice and this permission notice shall be included in all
|
||||
** copies or substantial portions of the Software.
|
||||
|
||||
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
** WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
*/
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "NvConvexDecomposition.h"
|
||||
#include "NvHashMap.h"
|
||||
#include "NvFloatMath.h"
|
||||
#include "NvRemoveTjunctions.h"
|
||||
#include "NvMeshIslandGeneration.h"
|
||||
#include "NvStanHull.h"
|
||||
#include "NvConcavityVolume.h"
|
||||
#include "NvSplitMesh.h"
|
||||
#include "NvThreadConfig.h"
|
||||
|
||||
|
||||
#pragma warning(disable:4996 4100 4189)
|
||||
|
||||
namespace CONVEX_DECOMPOSITION
|
||||
{
|
||||
|
||||
|
||||
#define GRANULARITY 0.0000000001f
|
||||
|
||||
typedef CONVEX_DECOMPOSITION::Array< NxU32 > NxU32Array;
|
||||
|
||||
class ConvexHull : public Memalloc
|
||||
{
|
||||
public:
|
||||
ConvexHull(NxU32 vcount,const NxF32 *vertices,NxU32 tcount,const NxU32 *indices)
|
||||
{
|
||||
mTested = false;
|
||||
mVcount = vcount;
|
||||
mTcount = tcount;
|
||||
mVertices = 0;
|
||||
mIndices = 0;
|
||||
mHullVolume = 0;
|
||||
if ( vcount )
|
||||
{
|
||||
mVertices = (NxF32 *)MEMALLOC_MALLOC(sizeof(NxF32)*3*vcount);
|
||||
memcpy(mVertices,vertices,sizeof(NxF32)*3*vcount);
|
||||
}
|
||||
if ( tcount )
|
||||
{
|
||||
mIndices = (NxU32 *)MEMALLOC_MALLOC(sizeof(NxU32)*3*tcount);
|
||||
memcpy(mIndices,indices,sizeof(NxU32)*3*tcount);
|
||||
}
|
||||
if ( mVcount && mTcount )
|
||||
{
|
||||
mHullVolume = fm_computeMeshVolume( mVertices, mTcount, mIndices);
|
||||
}
|
||||
}
|
||||
|
||||
~ConvexHull(void)
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
void reset(void)
|
||||
{
|
||||
MEMALLOC_FREE(mVertices);
|
||||
MEMALLOC_FREE(mIndices);
|
||||
mVertices = 0;
|
||||
mIndices = 0;
|
||||
mVcount = 0;
|
||||
mTcount = 0;
|
||||
mHullVolume = 0;
|
||||
}
|
||||
|
||||
// return true if merging this hull with the 'mergeHull' produces a new convex hull which is no greater in volume than the
|
||||
// mergeThresholdPercentage
|
||||
bool canMerge(ConvexHull *mergeHull,NxF32 mergeThresholdPercent,NxU32 maxVertices,NxF32 skinWidth,NxF32 &percent)
|
||||
{
|
||||
bool ret = false;
|
||||
|
||||
if ( mHullVolume > 0 && mergeHull->mHullVolume > 0 )
|
||||
{
|
||||
NxU32 combineVcount = mVcount + mergeHull->mVcount;
|
||||
NxF32 *vertices = (NxF32 *)MEMALLOC_MALLOC(sizeof(NxF32)*combineVcount*3);
|
||||
NxF32 *dest = vertices;
|
||||
const NxF32 *source = mVertices;
|
||||
|
||||
for (NxU32 i=0; i<mVcount; i++)
|
||||
{
|
||||
dest[0] = source[0];
|
||||
dest[1] = source[1];
|
||||
dest[2] = source[2];
|
||||
dest+=3;
|
||||
source+=3;
|
||||
}
|
||||
source = mergeHull->mVertices;
|
||||
for (NxU32 i=0; i<mergeHull->mVcount; i++)
|
||||
{
|
||||
dest[0] = source[0];
|
||||
dest[1] = source[1];
|
||||
dest[2] = source[2];
|
||||
dest+=3;
|
||||
source+=3;
|
||||
}
|
||||
|
||||
// create the combined convex hull.
|
||||
HullDesc hd;
|
||||
hd.mVcount = combineVcount;
|
||||
hd.mVertices = vertices;
|
||||
hd.mVertexStride = sizeof(NxF32)*3;
|
||||
hd.mMaxVertices = maxVertices;
|
||||
hd.mSkinWidth = skinWidth;
|
||||
HullLibrary hl;
|
||||
HullResult result;
|
||||
hl.CreateConvexHull(hd,result);
|
||||
|
||||
NxF32 combinedVolume = fm_computeMeshVolume(result.mOutputVertices, result.mNumFaces, result.mIndices );
|
||||
NxF32 seperateVolume = mHullVolume+mergeHull->mHullVolume;
|
||||
|
||||
NxF32 percentMerge = 100 - (seperateVolume*100 / combinedVolume );
|
||||
|
||||
if ( percentMerge <= mergeThresholdPercent )
|
||||
{
|
||||
percent = percentMerge;
|
||||
ret = true;
|
||||
}
|
||||
MEMALLOC_FREE(vertices);
|
||||
hl.ReleaseResult(result);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void merge(ConvexHull *mergeHull,NxU32 maxVertices,NxF32 skinWidth)
|
||||
{
|
||||
NxU32 combineVcount = mVcount + mergeHull->mVcount;
|
||||
NxF32 *vertices = (NxF32 *)MEMALLOC_MALLOC(sizeof(NxF32)*combineVcount*3);
|
||||
NxF32 *dest = vertices;
|
||||
const NxF32 *source = mVertices;
|
||||
|
||||
for (NxU32 i=0; i<mVcount; i++)
|
||||
{
|
||||
dest[0] = source[0];
|
||||
dest[1] = source[1];
|
||||
dest[2] = source[2];
|
||||
dest+=3;
|
||||
source+=3;
|
||||
}
|
||||
source = mergeHull->mVertices;
|
||||
for (NxU32 i=0; i<mergeHull->mVcount; i++)
|
||||
{
|
||||
dest[0] = source[0];
|
||||
dest[1] = source[1];
|
||||
dest[2] = source[2];
|
||||
dest+=3;
|
||||
source+=3;
|
||||
}
|
||||
|
||||
// create the combined convex hull.
|
||||
HullDesc hd;
|
||||
hd.mVcount = combineVcount;
|
||||
hd.mVertices = vertices;
|
||||
hd.mVertexStride = sizeof(NxF32)*3;
|
||||
hd.mMaxVertices = maxVertices;
|
||||
hd.mSkinWidth = skinWidth;
|
||||
HullLibrary hl;
|
||||
HullResult result;
|
||||
hl.CreateConvexHull(hd,result);
|
||||
|
||||
reset();
|
||||
mergeHull->reset();
|
||||
mergeHull->mTested = true; // it's been tested.
|
||||
mVcount = result.mNumOutputVertices;
|
||||
mVertices = (NxF32 *)MEMALLOC_MALLOC(sizeof(NxF32)*3*mVcount);
|
||||
memcpy(mVertices,result.mOutputVertices,sizeof(NxF32)*3*mVcount);
|
||||
mTcount = result.mNumFaces;
|
||||
mIndices = (NxU32 *)MEMALLOC_MALLOC(sizeof(NxU32)*mTcount*3);
|
||||
memcpy(mIndices, result.mIndices, sizeof(NxU32)*mTcount*3);
|
||||
|
||||
MEMALLOC_FREE(vertices);
|
||||
hl.ReleaseResult(result);
|
||||
}
|
||||
|
||||
void setTested(bool state)
|
||||
{
|
||||
mTested = state;
|
||||
}
|
||||
|
||||
bool beenTested(void) const { return mTested; };
|
||||
|
||||
bool mTested;
|
||||
NxF32 mHullVolume;
|
||||
NxU32 mVcount;
|
||||
NxF32 *mVertices;
|
||||
NxU32 mTcount;
|
||||
NxU32 *mIndices;
|
||||
};
|
||||
|
||||
typedef Array< ConvexHull *> ConvexHullVector;
|
||||
|
||||
class ConvexDecomposition : public iConvexDecomposition, public CONVEX_DECOMPOSITION::Memalloc, public ThreadInterface
|
||||
{
|
||||
public:
|
||||
ConvexDecomposition(void)
|
||||
{
|
||||
mVertexIndex = 0;
|
||||
mComplete = false;
|
||||
mCancel = false;
|
||||
mThread = 0;
|
||||
}
|
||||
|
||||
~ConvexDecomposition(void)
|
||||
{
|
||||
wait();
|
||||
reset();
|
||||
if ( mThread )
|
||||
{
|
||||
tc_releaseThread(mThread);
|
||||
}
|
||||
}
|
||||
|
||||
void wait(void) const
|
||||
{
|
||||
while ( mThread && !mComplete );
|
||||
}
|
||||
|
||||
virtual void reset(void) // reset the input mesh data.
|
||||
{
|
||||
wait();
|
||||
if ( mVertexIndex )
|
||||
{
|
||||
fm_releaseVertexIndex(mVertexIndex);
|
||||
mVertexIndex = 0;
|
||||
}
|
||||
mIndices.clear();
|
||||
ConvexHullVector::Iterator i;
|
||||
for (i=mHulls.begin(); i!=mHulls.end(); ++i)
|
||||
{
|
||||
ConvexHull *ch = (*i);
|
||||
delete ch;
|
||||
}
|
||||
mHulls.clear();
|
||||
}
|
||||
|
||||
virtual bool addTriangle(const NxF32 *p1,const NxF32 *p2,const NxF32 *p3)
|
||||
{
|
||||
bool ret = true;
|
||||
wait();
|
||||
if ( mVertexIndex == 0 )
|
||||
{
|
||||
mVertexIndex = fm_createVertexIndex(GRANULARITY,false);
|
||||
}
|
||||
|
||||
bool newPos;
|
||||
NxU32 i1 = mVertexIndex->getIndex(p1,newPos);
|
||||
NxU32 i2 = mVertexIndex->getIndex(p2,newPos);
|
||||
NxU32 i3 = mVertexIndex->getIndex(p3,newPos);
|
||||
|
||||
if ( i1 == i2 || i1 == i3 || i2 == i3 )
|
||||
{
|
||||
ret = false; // triangle is degenerate
|
||||
}
|
||||
else
|
||||
{
|
||||
mIndices.pushBack(i1);
|
||||
mIndices.pushBack(i2);
|
||||
mIndices.pushBack(i3);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
ConvexHull * getNonTested(void) const
|
||||
{
|
||||
ConvexHull *ret = 0;
|
||||
for (NxU32 i=0; i<mHulls.size(); i++)
|
||||
{
|
||||
ConvexHull *ch = mHulls[i];
|
||||
if ( !ch->beenTested() )
|
||||
{
|
||||
ret = ch;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
virtual NxU32 computeConvexDecomposition(NxF32 skinWidth,
|
||||
NxU32 decompositionDepth,
|
||||
NxU32 maxHullVertices,
|
||||
NxF32 concavityThresholdPercent,
|
||||
NxF32 mergeThresholdPercent,
|
||||
NxF32 volumeSplitThresholdPercent,
|
||||
bool useInitialIslandGeneration,
|
||||
bool useIslandGeneration,
|
||||
bool useThreads)
|
||||
{
|
||||
NxU32 ret = 0;
|
||||
|
||||
if ( mThread )
|
||||
return 0;
|
||||
|
||||
if ( mVertexIndex )
|
||||
{
|
||||
|
||||
mSkinWidth = skinWidth;
|
||||
mDecompositionDepth = decompositionDepth;
|
||||
mMaxHullVertices = maxHullVertices;
|
||||
mConcavityThresholdPercent = concavityThresholdPercent;
|
||||
mMergeThresholdPercent = mergeThresholdPercent;
|
||||
mVolumeSplitThresholdPercent = volumeSplitThresholdPercent;
|
||||
mUseInitialIslandGeneration = useInitialIslandGeneration;
|
||||
mUseIslandGeneration = false; // Not currently supported. useIslandGeneration;
|
||||
mComplete = false;
|
||||
mCancel = false;
|
||||
|
||||
if ( useThreads )
|
||||
{
|
||||
mThread = tc_createThread(this);
|
||||
}
|
||||
else
|
||||
{
|
||||
threadMain();
|
||||
ret = getHullCount();
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void performConvexDecomposition(NxU32 vcount,
|
||||
const NxF32 *vertices,
|
||||
NxU32 tcount,
|
||||
const NxU32 *indices,
|
||||
NxF32 skinWidth,
|
||||
NxU32 decompositionDepth,
|
||||
NxU32 maxHullVertices,
|
||||
NxF32 concavityThresholdPercent,
|
||||
NxF32 mergeThresholdPercent,
|
||||
NxF32 volumeSplitThresholdPercent,
|
||||
bool useInitialIslandGeneration,
|
||||
bool useIslandGeneration,
|
||||
NxU32 depth)
|
||||
{
|
||||
if ( mCancel ) return;
|
||||
if ( depth >= decompositionDepth ) return;
|
||||
|
||||
RemoveTjunctionsDesc desc;
|
||||
desc.mVcount = vcount;
|
||||
desc.mVertices = vertices;
|
||||
desc.mTcount = tcount;
|
||||
desc.mIndices = indices;
|
||||
|
||||
#if 0
|
||||
RemoveTjunctions *rt = createRemoveTjunctions();
|
||||
rt->removeTjunctions(desc);
|
||||
#else
|
||||
|
||||
desc.mTcountOut = desc.mTcount;
|
||||
desc.mIndicesOut = desc.mIndices;
|
||||
|
||||
#endif
|
||||
// ok..we now have a clean mesh without any tjunctions.
|
||||
bool island = (depth == 0 ) ? useInitialIslandGeneration : useIslandGeneration;
|
||||
if ( island )
|
||||
{
|
||||
MeshIslandGeneration *mi = createMeshIslandGeneration();
|
||||
NxU32 icount = mi->islandGenerate(desc.mTcountOut,desc.mIndicesOut,desc.mVertices);
|
||||
for (NxU32 i=0; i<icount && !mCancel; i++)
|
||||
{
|
||||
NxU32 tcount;
|
||||
NxU32 *indices = mi->getIsland(i,tcount);
|
||||
|
||||
baseConvexDecomposition(desc.mVcount,desc.mVertices,
|
||||
tcount,indices,
|
||||
skinWidth,
|
||||
decompositionDepth,
|
||||
maxHullVertices,
|
||||
concavityThresholdPercent,
|
||||
mergeThresholdPercent,
|
||||
volumeSplitThresholdPercent,
|
||||
useInitialIslandGeneration,
|
||||
useIslandGeneration,depth);
|
||||
}
|
||||
releaseMeshIslandGeneration(mi);
|
||||
}
|
||||
else
|
||||
{
|
||||
baseConvexDecomposition(desc.mVcount,desc.mVertices,desc.mTcountOut,
|
||||
desc.mIndicesOut,
|
||||
skinWidth,
|
||||
decompositionDepth,
|
||||
maxHullVertices,
|
||||
concavityThresholdPercent,
|
||||
mergeThresholdPercent,
|
||||
volumeSplitThresholdPercent,
|
||||
useInitialIslandGeneration,
|
||||
useIslandGeneration,depth);
|
||||
}
|
||||
#if 0
|
||||
releaseRemoveTjunctions(rt);
|
||||
#endif
|
||||
}
|
||||
|
||||
virtual void baseConvexDecomposition(NxU32 vcount,
|
||||
const NxF32 *vertices,
|
||||
NxU32 tcount,
|
||||
const NxU32 *indices,
|
||||
NxF32 skinWidth,
|
||||
NxU32 decompositionDepth,
|
||||
NxU32 maxHullVertices,
|
||||
NxF32 concavityThresholdPercent,
|
||||
NxF32 mergeThresholdPercent,
|
||||
NxF32 volumeSplitThresholdPercent,
|
||||
bool useInitialIslandGeneration,
|
||||
bool useIslandGeneration,
|
||||
NxU32 depth)
|
||||
{
|
||||
|
||||
if ( mCancel ) return;
|
||||
|
||||
bool split = false; // by default we do not split
|
||||
|
||||
|
||||
NxU32 *out_indices = (NxU32 *)MEMALLOC_MALLOC( sizeof(NxU32)*tcount*3 );
|
||||
NxF32 *out_vertices = (NxF32 *)MEMALLOC_MALLOC( sizeof(NxF32)*3*vcount );
|
||||
|
||||
NxU32 out_vcount = fm_copyUniqueVertices( vcount, vertices, out_vertices, tcount, indices, out_indices );
|
||||
// get a copy of only the unique vertices which are actually being used.
|
||||
|
||||
HullDesc hd;
|
||||
hd.mVcount = out_vcount;
|
||||
hd.mVertices = out_vertices;
|
||||
hd.mVertexStride = sizeof(NxF32)*3;
|
||||
hd.mMaxVertices = maxHullVertices;
|
||||
hd.mSkinWidth = skinWidth;
|
||||
HullLibrary hl;
|
||||
HullResult result;
|
||||
hl.CreateConvexHull(hd,result);
|
||||
|
||||
NxF32 meshVolume = fm_computeMeshVolume(result.mOutputVertices, result.mNumFaces, result.mIndices );
|
||||
|
||||
if ( (depth+1) < decompositionDepth )
|
||||
{
|
||||
// compute the volume of this mesh...
|
||||
NxF32 percentVolume = (meshVolume*100)/mOverallMeshVolume; // what percentage of the overall mesh volume are we?
|
||||
if ( percentVolume > volumeSplitThresholdPercent ) // this piece must be greater thant he volume split threshold percent
|
||||
{
|
||||
// ok..now we will compute the concavity...
|
||||
NxF32 concave_volume = computeConcavityVolume(result.mNumOutputVertices, result.mOutputVertices, result.mNumFaces, result.mIndices, out_vcount, out_vertices, tcount, out_indices );
|
||||
NxF32 concave_percent = (concave_volume*100) / meshVolume;
|
||||
if ( concave_percent >= concavityThresholdPercent )
|
||||
{
|
||||
// ready to do split here..
|
||||
split = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( !split )
|
||||
{
|
||||
saveConvexHull(result.mNumOutputVertices,result.mOutputVertices,result.mNumFaces,result.mIndices);
|
||||
}
|
||||
|
||||
// Compute the best fit plane relative to the computed convex hull.
|
||||
NxF32 plane[4];
|
||||
bool ok = fm_computeSplitPlane(result.mNumOutputVertices,result.mOutputVertices,result.mNumFaces,result.mIndices,plane);
|
||||
assert(ok);
|
||||
|
||||
hl.ReleaseResult(result);
|
||||
MEMALLOC_FREE(out_indices);
|
||||
MEMALLOC_FREE(out_vertices);
|
||||
|
||||
if ( split )
|
||||
{
|
||||
iSplitMesh *sm = createSplitMesh();
|
||||
|
||||
NvSplitMesh n;
|
||||
n.mVcount = vcount;
|
||||
n.mVertices = vertices;
|
||||
n.mTcount = tcount;
|
||||
n.mIndices = indices;
|
||||
if ( ok )
|
||||
{
|
||||
NvSplitMesh leftMesh;
|
||||
NvSplitMesh rightMesh;
|
||||
|
||||
sm->splitMesh(n,leftMesh,rightMesh,plane,GRANULARITY);
|
||||
|
||||
if ( leftMesh.mTcount )
|
||||
{
|
||||
performConvexDecomposition(leftMesh.mVcount,
|
||||
leftMesh.mVertices,
|
||||
leftMesh.mTcount,
|
||||
leftMesh.mIndices,
|
||||
skinWidth,
|
||||
decompositionDepth,
|
||||
maxHullVertices,
|
||||
concavityThresholdPercent,
|
||||
mergeThresholdPercent,
|
||||
volumeSplitThresholdPercent,
|
||||
useInitialIslandGeneration,
|
||||
useIslandGeneration,
|
||||
depth+1);
|
||||
|
||||
}
|
||||
if ( rightMesh.mTcount )
|
||||
{
|
||||
performConvexDecomposition(rightMesh.mVcount,
|
||||
rightMesh.mVertices,
|
||||
rightMesh.mTcount,
|
||||
rightMesh.mIndices,
|
||||
skinWidth,
|
||||
decompositionDepth,
|
||||
maxHullVertices,
|
||||
concavityThresholdPercent,
|
||||
mergeThresholdPercent,
|
||||
volumeSplitThresholdPercent,
|
||||
useInitialIslandGeneration,
|
||||
useIslandGeneration,
|
||||
depth+1);
|
||||
}
|
||||
}
|
||||
releaseSplitMesh(sm);
|
||||
}
|
||||
}
|
||||
|
||||
// Copies only the vertices which are actually used.
|
||||
// Then computes the convex hull around these used vertices.
|
||||
// Next computes the volume of this convex hull.
|
||||
// Frees up scratch memory and returns the volume of the convex hull around the source triangle mesh.
|
||||
NxF32 computeHullMeshVolume(NxU32 vcount,const NxF32 *vertices,NxU32 tcount,const NxU32 *indices,NxU32 maxVertices,NxF32 skinWidth)
|
||||
{
|
||||
if ( mCancel ) return 0;
|
||||
// first thing we should do is compute the overall mesh volume.
|
||||
NxU32 *out_indices = (NxU32 *)MEMALLOC_MALLOC( sizeof(NxU32)*tcount*3 );
|
||||
NxF32 *out_vertices = (NxF32 *)MEMALLOC_MALLOC( sizeof(NxF32)*3*vcount );
|
||||
|
||||
NxU32 out_vcount = fm_copyUniqueVertices( vcount, vertices, out_vertices, tcount, indices, out_indices );
|
||||
// get a copy of only the unique vertices which are actually being used.
|
||||
|
||||
HullDesc hd;
|
||||
hd.mVcount = out_vcount;
|
||||
hd.mVertices = out_vertices;
|
||||
hd.mVertexStride = sizeof(NxF32)*3;
|
||||
hd.mMaxVertices = maxVertices;
|
||||
hd.mSkinWidth = skinWidth;
|
||||
HullLibrary hl;
|
||||
HullResult result;
|
||||
hl.CreateConvexHull(hd,result);
|
||||
|
||||
NxF32 volume = fm_computeMeshVolume(result.mOutputVertices, result.mNumFaces, result.mIndices );
|
||||
|
||||
hl.ReleaseResult(result);
|
||||
MEMALLOC_FREE(out_indices);
|
||||
MEMALLOC_FREE(out_vertices);
|
||||
|
||||
return volume;
|
||||
}
|
||||
|
||||
|
||||
virtual bool isComputeComplete(void) // if building the convex hulls in a background thread, this returns true if it is complete.
|
||||
{
|
||||
bool ret = true;
|
||||
|
||||
if ( mThread )
|
||||
{
|
||||
ret = mComplete;
|
||||
if ( ret )
|
||||
{
|
||||
tc_releaseThread(mThread);
|
||||
mThread = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
virtual NxU32 getHullCount(void)
|
||||
{
|
||||
NxU32 hullCount = 0;
|
||||
wait();
|
||||
if ( mCancel )
|
||||
{
|
||||
reset();
|
||||
}
|
||||
for (NxU32 i=0; i<mHulls.size(); i++)
|
||||
{
|
||||
ConvexHull *ch = mHulls[i];
|
||||
if ( ch->mTcount )
|
||||
{
|
||||
hullCount++;
|
||||
}
|
||||
}
|
||||
return hullCount;
|
||||
}
|
||||
|
||||
virtual bool getConvexHullResult(NxU32 hullIndex,ConvexHullResult &result)
|
||||
{
|
||||
bool ret = false;
|
||||
|
||||
wait();
|
||||
NxU32 index = 0;
|
||||
for (NxU32 i=0; i<mHulls.size(); i++)
|
||||
{
|
||||
ConvexHull *ch = mHulls[i];
|
||||
if ( ch->mTcount )
|
||||
{
|
||||
if ( hullIndex == index )
|
||||
{
|
||||
ret = true;
|
||||
result.mVcount = ch->mVcount;
|
||||
result.mTcount = ch->mTcount;
|
||||
result.mVertices = ch->mVertices;
|
||||
result.mIndices = ch->mIndices;
|
||||
break;
|
||||
}
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void saveConvexHull(NxU32 vcount,const NxF32 *vertices,NxU32 tcount,const NxU32 *indices)
|
||||
{
|
||||
ConvexHull *ch = MEMALLOC_NEW(ConvexHull)(vcount,vertices,tcount,indices);
|
||||
mHulls.pushBack(ch);
|
||||
}
|
||||
|
||||
virtual void threadMain(void)
|
||||
{
|
||||
mOverallMeshVolume = computeHullMeshVolume( mVertexIndex->getVcount(),
|
||||
mVertexIndex->getVerticesFloat(),
|
||||
mIndices.size()/3,
|
||||
&mIndices[0],
|
||||
mMaxHullVertices, mSkinWidth );
|
||||
|
||||
performConvexDecomposition(mVertexIndex->getVcount(),mVertexIndex->getVerticesFloat(),
|
||||
mIndices.size()/3,&mIndices[0],
|
||||
mSkinWidth,
|
||||
mDecompositionDepth,
|
||||
mMaxHullVertices,
|
||||
mConcavityThresholdPercent,
|
||||
mMergeThresholdPercent,
|
||||
mVolumeSplitThresholdPercent,
|
||||
mUseInitialIslandGeneration,
|
||||
mUseIslandGeneration,0);
|
||||
|
||||
if ( mHulls.size() && !mCancel )
|
||||
{
|
||||
// While convex hulls can be merged...
|
||||
ConvexHull *ch = getNonTested();
|
||||
while ( ch && !mCancel )
|
||||
{
|
||||
// Sort all convex hulls by volume, largest to smallest.
|
||||
NxU32 hullCount = mHulls.size();
|
||||
ConvexHull *bestHull = 0;
|
||||
NxF32 bestPercent = 100;
|
||||
|
||||
for (NxU32 i=0; i<hullCount; i++)
|
||||
{
|
||||
ConvexHull *mergeHull = mHulls[i];
|
||||
if ( !mergeHull->beenTested() && mergeHull != ch )
|
||||
{
|
||||
NxF32 percent;
|
||||
if ( ch->canMerge(mergeHull,mMergeThresholdPercent,mMaxHullVertices,mSkinWidth,percent) )
|
||||
{
|
||||
if ( percent < bestPercent )
|
||||
{
|
||||
bestHull = mergeHull;
|
||||
bestPercent = percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( bestHull )
|
||||
{
|
||||
ch->merge(bestHull,mMaxHullVertices,mSkinWidth);
|
||||
}
|
||||
else
|
||||
{
|
||||
ch->setTested(true);
|
||||
}
|
||||
|
||||
ch = getNonTested();
|
||||
}
|
||||
}
|
||||
mComplete = true;
|
||||
}
|
||||
|
||||
virtual bool cancelCompute(void) // cause background thread computation to abort early. Will return no results. Use 'isComputeComplete' to confirm the thread is done.
|
||||
{
|
||||
bool ret = false;
|
||||
|
||||
if ( mThread && !mComplete )
|
||||
{
|
||||
mCancel = true;
|
||||
ret = true;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
private:
|
||||
bool mComplete;
|
||||
bool mCancel;
|
||||
fm_VertexIndex *mVertexIndex;
|
||||
NxU32Array mIndices;
|
||||
NxF32 mOverallMeshVolume;
|
||||
ConvexHullVector mHulls;
|
||||
Thread *mThread;
|
||||
|
||||
NxF32 mSkinWidth;
|
||||
NxU32 mDecompositionDepth;
|
||||
NxU32 mMaxHullVertices;
|
||||
NxF32 mConcavityThresholdPercent;
|
||||
NxF32 mMergeThresholdPercent;
|
||||
NxF32 mVolumeSplitThresholdPercent;
|
||||
bool mUseInitialIslandGeneration;
|
||||
bool mUseIslandGeneration;
|
||||
|
||||
};
|
||||
|
||||
|
||||
iConvexDecomposition * createConvexDecomposition(void)
|
||||
{
|
||||
ConvexDecomposition *cd = MEMALLOC_NEW(ConvexDecomposition);
|
||||
return static_cast< iConvexDecomposition *>(cd);
|
||||
|
||||
}
|
||||
|
||||
void releaseConvexDecomposition(iConvexDecomposition *ic)
|
||||
{
|
||||
ConvexDecomposition *cd = static_cast< ConvexDecomposition *>(ic);
|
||||
delete cd;
|
||||
}
|
||||
|
||||
}; // end of namespace
|
||||
Loading…
Add table
Add a link
Reference in a new issue