Пример #1
0
 virtual void getFaceNormal(uint32 tri,float *faceNormal)
 {
     if ( mFaceNormals == NULL )
     {
         mFaceNormals = (float *)::malloc(sizeof(float)*3*mTcount);
         for (uint32 i=0; i<mTcount; i++)
         {
             uint32 i1 = mIndices[i*3+0];
             uint32 i2 = mIndices[i*3+1];
             uint32 i3 = mIndices[i*3+2];
             const float*p1 = &mVertices[i1*3];
             const float*p2 = &mVertices[i2*3];
             const float*p3 = &mVertices[i3*3];
             float *dest = &mFaceNormals[i*3];
             computePlane(p3,p2,p1,dest);
         }
     }
     const float *src = &mFaceNormals[tri*3];
     faceNormal[0] = src[0];
     faceNormal[1] = src[1];
     faceNormal[2] = src[2];
 }
Пример #2
0
bool computeSplitPlane(unsigned int vcount,
                       const float *vertices,
                       unsigned int tcount,
                       const unsigned int *indices,
                       ConvexDecompInterface *callback,
                       float *plane)
{
  bool cret = false;


  float bmin[3] = { 1e9, 1e9, 1e9 };
  float bmax[3] = { -1e9, -1e9, -1e9 };

 	for (unsigned int i=0; i<vcount; i++)
 	{
    const float *p = &vertices[i*3];

 		if ( p[0] < bmin[0] ) bmin[0] = p[0];
 		if ( p[1] < bmin[1] ) bmin[1] = p[1];
 		if ( p[2] < bmin[2] ) bmin[2] = p[2];

 		if ( p[0] > bmax[0] ) bmax[0] = p[0];
 		if ( p[1] > bmax[1] ) bmax[1] = p[1];
 		if ( p[2] > bmax[2] ) bmax[2] = p[2];

  }

  float dx = bmax[0] - bmin[0];
  float dy = bmax[1] - bmin[1];
  float dz = bmax[2] - bmin[2];


	float laxis = dx;

	unsigned int axis = 0;

	if ( dy > dx )
	{
		axis = 1;
		laxis = dy;
	}

	if ( dz > dx && dz > dy )
	{
		axis = 2;
		laxis = dz;
	}

  float p1[3];
  float p2[3];
  float p3[3];

  p3[0] = p2[0] = p1[0] = bmin[0] + dx*0.5f;
  p3[1] = p2[1] = p1[1] = bmin[1] + dy*0.5f;
  p3[2] = p2[2] = p1[2] = bmin[2] + dz*0.5f;

  Rect3d b(bmin,bmax);

  Rect3d b1,b2;

  splitRect(axis,b,b1,b2,p1);


//  callback->ConvexDebugBound(b1.mMin,b1.mMax,0x00FF00);
//  callback->ConvexDebugBound(b2.mMin,b2.mMax,0xFFFF00);

  switch ( axis )
  {
    case 0:
      p2[1] = bmin[1];
      p2[2] = bmin[2];

      if ( dz > dy )
      {
        p3[1] = bmax[1];
        p3[2] = bmin[2];
      }
      else
      {
        p3[1] = bmin[1];
        p3[2] = bmax[2];
      }

      break;
    case 1:
      p2[0] = bmin[0];
      p2[2] = bmin[2];

      if ( dx > dz )
      {
        p3[0] = bmax[0];
        p3[2] = bmin[2];
      }
      else
      {
        p3[0] = bmin[0];
        p3[2] = bmax[2];
      }

      break;
    case 2:
      p2[0] = bmin[0];
      p2[1] = bmin[1];

      if ( dx > dy )
      {
        p3[0] = bmax[0];
        p3[1] = bmin[1];
      }
      else
      {
        p3[0] = bmin[0];
        p3[1] = bmax[1];
      }

      break;
  }

//  callback->ConvexDebugTri(p1,p2,p3,0xFF0000);

	computePlane(p1,p2,p3,plane);

  return true;

}
Пример #3
0
bool computeSplitPlane(unsigned int vcount,
                       const double *vertices,
                       unsigned int tcount,
                       const unsigned int *indices,
                       ConvexDecompInterface *callback,
                       double *plane)
{
  bool cret = false;


  double sides[3];
  double matrix[16];

  computeBestFitOBB( vcount, vertices, sizeof(double)*3, sides, matrix );

  double bmax[3];
  double bmin[3];

  bmax[0] = sides[0]*0.5f;
  bmax[1] = sides[1]*0.5f;
  bmax[2] = sides[2]*0.5f;

  bmin[0] = -bmax[0];
  bmin[1] = -bmax[1];
  bmin[2] = -bmax[2];


  double dx = sides[0];
  double dy = sides[1];
  double dz = sides[2];


	double laxis = dx;

	unsigned int axis = 0;

	if ( dy > dx )
	{
		axis = 1;
		laxis = dy;
	}

	if ( dz > dx && dz > dy )
	{
		axis = 2;
		laxis = dz;
	}

  double p1[3];
  double p2[3];
  double p3[3];

  p3[0] = p2[0] = p1[0] = bmin[0] + dx*0.5f;
  p3[1] = p2[1] = p1[1] = bmin[1] + dy*0.5f;
  p3[2] = p2[2] = p1[2] = bmin[2] + dz*0.5f;

  Rect3d b(bmin,bmax);

  Rect3d b1,b2;

  splitRect(axis,b,b1,b2,p1);


//  callback->ConvexDebugBound(b1.mMin,b1.mMax,0x00FF00);
//  callback->ConvexDebugBound(b2.mMin,b2.mMax,0xFFFF00);

  switch ( axis )
  {
    case 0:
      p2[1] = bmin[1];
      p2[2] = bmin[2];

      if ( dz > dy )
      {
        p3[1] = bmax[1];
        p3[2] = bmin[2];
      }
      else
      {
        p3[1] = bmin[1];
        p3[2] = bmax[2];
      }

      break;
    case 1:
      p2[0] = bmin[0];
      p2[2] = bmin[2];

      if ( dx > dz )
      {
        p3[0] = bmax[0];
        p3[2] = bmin[2];
      }
      else
      {
        p3[0] = bmin[0];
        p3[2] = bmax[2];
      }

      break;
    case 2:
      p2[0] = bmin[0];
      p2[1] = bmin[1];

      if ( dx > dy )
      {
        p3[0] = bmax[0];
        p3[1] = bmin[1];
      }
      else
      {
        p3[0] = bmin[0];
        p3[1] = bmax[1];
      }

      break;
  }

  double tp1[3];
  double tp2[3];
  double tp3[3];

  fm_transform(matrix,p1,tp1);
  fm_transform(matrix,p2,tp2);
  fm_transform(matrix,p3,tp3);

//  callback->ConvexDebugTri(p1,p2,p3,0xFF0000);

	computePlane(tp1,tp2,tp3,plane);

  return true;

}