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