Exemple #1
0
			void ReleaseHull( PHullResult result)
			{
				if( result.m_Indices.Count > 0 )
				{
					result.m_Indices.Clear();
				}
				result.mVcount = 0;
				result.mIndexCount = 0;
				result.mVertices = null;
			}
Exemple #2
0
			//*****************************
			//*****************************
			//*[]*  HullLib header
			//*****************************
			//*****************************

			//*****************************
			//*****************************
			//*[]*  HullLib implementation
			//*****************************
			//*****************************

			HullError CreateConvexHull( HullDesc       desc,           // describes the input request
										HullResult           result)         // contains the resulst
			{
				HullError ret = HullError.QE_FAIL;

				PHullResult hr = new PHullResult();

				int vcount = desc.mVcount;
				if( vcount < 8 ) vcount = 8;

				btList<btVector3> vertexSource = new btList<btVector3>();
				vertexSource.Count = vertexSource.Capacity = ( (int)vcount  );

				btVector3 scale = btVector3.Zero;

				int ovcount;

				bool ok = CleanupVertices( desc.mVcount, desc.mVertices.InternalArray, desc.mVertexStride
						, out ovcount, vertexSource, desc.mNormalEpsilon, ref scale ); // normalize point cloud, remove duplicates!

				if( ok )
				{


					//		if ( 1 ) // scale vertices back to their original size.
					{
						for( uint i = 0; i < ovcount; i++ )
						{
							btVector3 v = vertexSource[(int)( i )];
							v[0] = scale[0];
							v[1] = scale[1];
							v[2] = scale[2];
						}
					}

					ok = ComputeHull( ovcount, vertexSource.InternalArray, hr, desc.mMaxVertices );

					if( ok )
					{

						// re-index triangle mesh so it refers to only used vertices, rebuild a new vertex table.
						btList<btVector3> vertexScratch = new btList<btVector3>( (int)hr.mVcount );

						BringOutYourDead( hr.mVertices, hr.mVcount, vertexScratch, out ovcount, hr.m_Indices, hr.mIndexCount );

						ret = HullError.QE_OK;

						if( desc.HasHullFlag( HullFlag.QF_TRIANGLES ) ) // if he wants the results as triangle!
						{
							result.mPolygons = false;
							result.mNumOutputVertices = ovcount;
							result.m_OutputVertices.Count = result.m_OutputVertices.Capacity = ovcount;
							result.mNumFaces = hr.mFaceCount;
							result.mNumIndices = hr.mIndexCount;

							result.m_Indices.Count = result.m_Indices.Capacity = hr.mIndexCount;
							for( int j = 0; j < ovcount; j++ )
								result.m_OutputVertices[j] = vertexScratch[j];
							//memcpy( result.m_OutputVertices, vertexScratch, sizeof( btVector3 ) * ovcount );

							uint[] source = hr.m_Indices.InternalArray;
							uint[] dest = result.m_Indices.InternalArray;
							if( desc.HasHullFlag( HullFlag.QF_REVERSE_ORDER ) )
							{


								for( uint i = 0; i < hr.mFaceCount; i++ )
								{
									//dest = source;
									dest[i*3+0] = source[i*3+2];
									dest[i * 3 + 1] = source[i * 3 + 1];
									dest[i * 3 + 2] = source[i * 3 + 0];
									//dest += 3;
									//source += 3;
								}

							}
							else
							{
								for( int i = 0; i < 3*hr.mIndexCount; i++ )
									dest[i] = source[i];
								//memcpy( result.m_Indices, hr.m_Indices, sizeof( uint ) * hr.mIndexCount );
							}
						}
						else
						{

							result.mPolygons = true;
							result.mNumOutputVertices = ovcount;
							result.m_OutputVertices.Count = result.m_OutputVertices.Capacity = ovcount;
							result.mNumFaces = hr.mFaceCount;
							result.mNumIndices = hr.mIndexCount + hr.mFaceCount;
							result.m_Indices.Count = result.m_Indices.Capacity = ( result.mNumIndices );
							{
								btVector3[] dest = result.m_OutputVertices.InternalArray;
								btVector3[] source = vertexScratch.InternalArray;
								for( int i = 0; i < 3 * hr.mIndexCount; i++ )
									dest[i] = source[i];
							}
							//memcpy( result.m_OutputVertices, vertexScratch, sizeof( btVector3 ) * ovcount );

							//				if ( 1 )
							{
								uint[] source = hr.m_Indices.InternalArray;
								uint[] dest = result.m_Indices.InternalArray;
								for( uint i = 0; i < hr.mFaceCount; i++ )
								{
									dest[i*4 + 0] = 3;
									if( desc.HasHullFlag( HullFlag.QF_REVERSE_ORDER ) )
									{
										dest[i * 4 + 1] = source[i * 3 + 2];
										dest[i * 4 + 2] = source[i * 3 + 1];
										dest[i * 4 + 3] = source[i * 3 + 0];
									}
									else
									{
										dest[i * 4 + 1] = source[i * 3 + 0];
										dest[i * 4 + 2] = source[i * 3 + 1];
										dest[i * 4 + 3] = source[i*3+2];
									}

									//dest += 4;
									//source += 3;
								}
							}
						}
						ReleaseHull( hr );
					}
				}

				return ret;
			}
Exemple #3
0
			bool ComputeHull( int vcount, btVector3[] vertices, PHullResult result, int vlimit )
			{

				int tris_count;
				int ret = calchull( vertices, (int)vcount, out result.m_Indices, out tris_count,  (int)vlimit  );
				if( ret == 0 ) {
					return false;
				}
				result.mIndexCount = ( tris_count * 3 );
				result.mFaceCount = tris_count;
				result.mVertices.Add( vertices );
				result.mVcount = vcount;
				return true;

			}