Logo Search packages:      
Sourcecode: blender version File versions  Download package

BvhTriangleMeshShape.cpp

/*
 * Copyright (c) 2006 Erwin Coumans http://continuousphysics.com/Bullet/
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies.
 * Erwin Coumans makes no representations about the suitability 
 * of this software for any purpose.  
 * It is provided "as is" without express or implied warranty.
*/

//#define DISABLE_BVH


#include "CollisionShapes/BvhTriangleMeshShape.h"
#include "CollisionShapes/OptimizedBvh.h"

///Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization.
///Uses an interface to access the triangles to allow for sharing graphics/physics triangles.
00020 BvhTriangleMeshShape::BvhTriangleMeshShape(StridingMeshInterface* meshInterface)
:TriangleMeshShape(meshInterface)
{
      //construct bvh from meshInterface
#ifndef DISABLE_BVH

      m_bvh = new OptimizedBvh();
      m_bvh->Build(meshInterface);

#endif //DISABLE_BVH

}

BvhTriangleMeshShape::~BvhTriangleMeshShape()
{
      delete m_bvh;
}

//perform bvh tree traversal and report overlapping triangles to 'callback'
void  BvhTriangleMeshShape::ProcessAllTriangles(TriangleCallback* callback,const SimdVector3& aabbMin,const SimdVector3& aabbMax) const
{

#ifdef DISABLE_BVH
      //brute force traverse all triangles
      TriangleMeshShape::ProcessAllTriangles(callback,aabbMin,aabbMax);
#else

      //first get all the nodes

      
      struct      MyNodeOverlapCallback : public NodeOverlapCallback
      {
            StridingMeshInterface*  m_meshInterface;
            TriangleCallback*       m_callback;
            SimdVector3                   m_triangle[3];


            MyNodeOverlapCallback(TriangleCallback* callback,StridingMeshInterface* meshInterface)
                  :m_callback(callback),
                  m_meshInterface(meshInterface)
            {
            }
                        
            virtual void ProcessNode(const OptimizedBvhNode* node)
            {
                  const unsigned char *vertexbase;
                  int numverts;
                  PHY_ScalarType type;
                  int stride;
                  const unsigned char *indexbase;
                  int indexstride;
                  int numfaces;
                  PHY_ScalarType indicestype;
                  

                  m_meshInterface->getLockedReadOnlyVertexIndexBase(
                        &vertexbase,
                        numverts,
                        type,
                        stride,
                        &indexbase,
                        indexstride,
                        numfaces,
                        indicestype,
                        node->m_subPart);

                  int* gfxbase = (int*)(indexbase+node->m_triangleIndex*indexstride);
                  
                  const SimdVector3& meshScaling = m_meshInterface->getScaling();
                  for (int j=2;j>=0;j--)
                  {
                        
                        int graphicsindex = gfxbase[j];
#ifdef DEBUG_TRIANGLE_MESH
                        printf("%d ,",graphicsindex);
#endif //DEBUG_TRIANGLE_MESH
                        float* graphicsbase = (float*)(vertexbase+graphicsindex*stride);

                        m_triangle[j] = SimdVector3(
                              graphicsbase[0]*meshScaling.getX(),
                              graphicsbase[1]*meshScaling.getY(),
                              graphicsbase[2]*meshScaling.getZ());
#ifdef DEBUG_TRIANGLE_MESH
                        printf("triangle vertices:%f,%f,%f\n",triangle[j].x(),triangle[j].y(),triangle[j].z());
#endif //DEBUG_TRIANGLE_MESH
                  }

                  m_callback->ProcessTriangle(m_triangle);
                  m_meshInterface->unLockReadOnlyVertexBase(node->m_subPart);
            }

      };

      MyNodeOverlapCallback   myNodeCallback(callback,m_meshInterface);

      m_bvh->ReportAabbOverlappingNodex(&myNodeCallback,aabbMin,aabbMax);


#endif//DISABLE_BVH


}


void  BvhTriangleMeshShape::setLocalScaling(const SimdVector3& scaling)
{
      if ((getLocalScaling() -scaling).length2() > SIMD_EPSILON)
      {
            TriangleMeshShape::setLocalScaling(scaling);
            delete m_bvh;
            m_bvh = new OptimizedBvh();
            m_bvh->Build(m_meshInterface);
            //rebuild the bvh...
      }
}

Generated by  Doxygen 1.6.0   Back to index