Back to index

supertuxkart  0.5+dfsg1
Static Public Member Functions
btGeometryUtil Class Reference

#include <btGeometryUtil.h>

List of all members.

Static Public Member Functions

static void getPlaneEquationsFromVertices (btAlignedObjectArray< btVector3 > &vertices, btAlignedObjectArray< btVector3 > &planeEquationsOut)
static void getVerticesFromPlaneEquations (const btAlignedObjectArray< btVector3 > &planeEquations, btAlignedObjectArray< btVector3 > &verticesOut)
static bool isInside (const btAlignedObjectArray< btVector3 > &vertices, const btVector3 &planeNormal, btScalar margin)
static bool isPointInsidePlanes (const btAlignedObjectArray< btVector3 > &planeEquations, const btVector3 &point, btScalar margin)
static bool areVerticesBehindPlane (const btVector3 &planeNormal, const btAlignedObjectArray< btVector3 > &vertices, btScalar margin)

Detailed Description

Definition at line 22 of file btGeometryUtil.h.


Member Function Documentation

bool btGeometryUtil::areVerticesBehindPlane ( const btVector3 planeNormal,
const btAlignedObjectArray< btVector3 > &  vertices,
btScalar  margin 
) [static]

Definition at line 45 of file btGeometryUtil.cpp.

{
       int numvertices = vertices.size();
       for (int i=0;i<numvertices;i++)
       {
              const btVector3& N1 = vertices[i];
              btScalar dist = btScalar(planeNormal.dot(N1))+btScalar(planeNormal[3])-margin;
              if (dist>btScalar(0.))
              {
                     return false;
              }
       }
       return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 74 of file btGeometryUtil.cpp.

{
              const int numvertices = vertices.size();
       // brute force:
       for (int i=0;i<numvertices;i++)
       {
              const btVector3& N1 = vertices[i];
              

              for (int j=i+1;j<numvertices;j++)
              {
                     const btVector3& N2 = vertices[j];
                            
                     for (int k=j+1;k<numvertices;k++)
                     {

                            const btVector3& N3 = vertices[k];

                            btVector3 planeEquation,edge0,edge1;
                            edge0 = N2-N1;
                            edge1 = N3-N1;
                            btScalar normalSign = btScalar(1.);
                            for (int ww=0;ww<2;ww++)
                            {
                                   planeEquation = normalSign * edge0.cross(edge1);
                                   if (planeEquation.length2() > btScalar(0.0001))
                                   {
                                          planeEquation.normalize();
                                          if (notExist(planeEquation,planeEquationsOut))
                                          {
                                                 planeEquation[3] = -planeEquation.dot(N1);
                                                 
                                                        //check if inside, and replace supportingVertexOut if needed
                                                        if (areVerticesBehindPlane(planeEquation,vertices,btScalar(0.01)))
                                                        {
                                                               planeEquationsOut.push_back(planeEquation);
                                                        }
                                          }
                                   }
                                   normalSign = btScalar(-1.);
                            }
                     
                     }
              }
       }

}

Here is the call graph for this function:

void btGeometryUtil::getVerticesFromPlaneEquations ( const btAlignedObjectArray< btVector3 > &  planeEquations,
btAlignedObjectArray< btVector3 > &  verticesOut 
) [static]

Definition at line 122 of file btGeometryUtil.cpp.

{
       const int numbrushes = planeEquations.size();
       // brute force:
       for (int i=0;i<numbrushes;i++)
       {
              const btVector3& N1 = planeEquations[i];
              

              for (int j=i+1;j<numbrushes;j++)
              {
                     const btVector3& N2 = planeEquations[j];
                            
                     for (int k=j+1;k<numbrushes;k++)
                     {

                            const btVector3& N3 = planeEquations[k];

                            btVector3 n2n3; n2n3 = N2.cross(N3);
                            btVector3 n3n1; n3n1 = N3.cross(N1);
                            btVector3 n1n2; n1n2 = N1.cross(N2);
                            
                            if ( ( n2n3.length2() > btScalar(0.0001) ) &&
                                    ( n3n1.length2() > btScalar(0.0001) ) &&
                                    ( n1n2.length2() > btScalar(0.0001) ) )
                            {
                                   //point P out of 3 plane equations:

                                   //     d1 ( N2 * N3 ) + d2 ( N3 * N1 ) + d3 ( N1 * N2 )  
                                   //P =  -------------------------------------------------------------------------  
                                   //   N1 . ( N2 * N3 )  


                                   btScalar quotient = (N1.dot(n2n3));
                                   if (btFabs(quotient) > btScalar(0.000001))
                                   {
                                          quotient = btScalar(-1.) / quotient;
                                          n2n3 *= N1[3];
                                          n3n1 *= N2[3];
                                          n1n2 *= N3[3];
                                          btVector3 potentialVertex = n2n3;
                                          potentialVertex += n3n1;
                                          potentialVertex += n1n2;
                                          potentialVertex *= quotient;

                                          //check if inside, and replace supportingVertexOut if needed
                                          if (isPointInsidePlanes(planeEquations,potentialVertex,btScalar(0.01)))
                                          {
                                                 verticesOut.push_back(potentialVertex);
                                          }
                                   }
                            }
                     }
              }
       }
}

Here is the call graph for this function:

static bool btGeometryUtil::isInside ( const btAlignedObjectArray< btVector3 > &  vertices,
const btVector3 planeNormal,
btScalar  margin 
) [static]
bool btGeometryUtil::isPointInsidePlanes ( const btAlignedObjectArray< btVector3 > &  planeEquations,
const btVector3 point,
btScalar  margin 
) [static]

Definition at line 28 of file btGeometryUtil.cpp.

{
       int numbrushes = planeEquations.size();
       for (int i=0;i<numbrushes;i++)
       {
              const btVector3& N1 = planeEquations[i];
              btScalar dist = btScalar(N1.dot(point))+btScalar(N1[3])-margin;
              if (dist>btScalar(0.))
              {
                     return false;
              }
       }
       return true;
              
}

Here is the call graph for this function:

Here is the caller graph for this function:


The documentation for this class was generated from the following files: