btCompoundFromGimpact.h

Go to the documentation of this file.

#ifndef BT_COMPOUND_FROM_GIMPACT
#define BT_COMPOUND_FROM_GIMPACT
 
#include "BulletCollision/CollisionShapes/btCompoundShape.h"
#include "btGImpactShape.h"
#include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h"
 
ATTRIBUTE_ALIGNED16(class) btCompoundFromGimpactShape   : public btCompoundShape
{
public:
        BT_DECLARE_ALIGNED_ALLOCATOR();
 
        virtual ~btCompoundFromGimpactShape()
        {
                /*delete all the btBU_Simplex1to4 ChildShapes*/
                for (int i = 0; i < m_children.size(); i++)
                {
                        delete m_children[i].m_childShape;
                }
        }
 
};
 
struct MyCallback : public btTriangleRaycastCallback
                {
                        int     m_ignorePart;
                        int     m_ignoreTriangleIndex;
                        
 
                        MyCallback(const btVector3& from, const btVector3& to, int ignorePart, int ignoreTriangleIndex)
                        :btTriangleRaycastCallback(from,to),
                        m_ignorePart(ignorePart),
                        m_ignoreTriangleIndex(ignoreTriangleIndex)
                        {
                                
                        }
                        virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex)
                        {
                                if (partId!=m_ignorePart || triangleIndex!=m_ignoreTriangleIndex)
                                {
                                        if (hitFraction < m_hitFraction)
                                                return hitFraction;
                                }
 
                                return m_hitFraction;
                        }
                };
                struct MyInternalTriangleIndexCallback :public btInternalTriangleIndexCallback
                {
                        const btGImpactMeshShape*               m_gimpactShape;
                        btCompoundShape*                        m_colShape;
                        btScalar        m_depth;
 
                        MyInternalTriangleIndexCallback (btCompoundShape* colShape, const btGImpactMeshShape* meshShape, btScalar depth)
                        :m_colShape(colShape),
                        m_gimpactShape(meshShape),
                        m_depth(depth)
                        {
                        }
                        
                        virtual void internalProcessTriangleIndex(btVector3* triangle,int partId,int  triangleIndex)
                        {
                                btVector3 scale = m_gimpactShape->getLocalScaling();
                                btVector3 v0=triangle[0]*scale;
                                btVector3 v1=triangle[1]*scale;
                                btVector3 v2=triangle[2]*scale;
                                
                                btVector3 centroid = (v0+v1+v2)/3;
                                btVector3 normal = (v1-v0).cross(v2-v0);
                                normal.normalize();
                                btVector3 rayFrom = centroid;
                                btVector3 rayTo = centroid-normal*m_depth;
                                
                                MyCallback cb(rayFrom,rayTo,partId,triangleIndex);
                                
                                m_gimpactShape->processAllTrianglesRay(&cb,rayFrom, rayTo);
                                if (cb.m_hitFraction<1)
                                {
                                        rayTo.setInterpolate3(cb.m_from,cb.m_to,cb.m_hitFraction);
                                        //rayTo = cb.m_from;
                                        //rayTo = rayTo.lerp(cb.m_to,cb.m_hitFraction);
                                        //gDebugDraw.drawLine(tr(centroid),tr(centroid+normal),btVector3(1,0,0));
                                }
                                
 
                                
                                btBU_Simplex1to4* tet = new btBU_Simplex1to4(v0,v1,v2,rayTo);
                                btTransform ident;
                                ident.setIdentity();
                                m_colShape->addChildShape(ident,tet);
                        }
                };
                
btCompoundShape*        btCreateCompoundFromGimpactShape(const btGImpactMeshShape* gimpactMesh, btScalar depth)
{
        btCompoundShape* colShape = new btCompoundFromGimpactShape();
                
                btTransform tr;
                tr.setIdentity();
                
                MyInternalTriangleIndexCallback cb(colShape,gimpactMesh, depth);
                btVector3 aabbMin,aabbMax;
                gimpactMesh->getAabb(tr,aabbMin,aabbMax);
                gimpactMesh->getMeshInterface()->InternalProcessAllTriangles(&cb,aabbMin,aabbMax);
 
        return colShape;        
}       
 
#endif //BT_COMPOUND_FROM_GIMPACT