cleaned up FractureDemo, still need to apply the velocity/impulses after the fracture took place
This commit is contained in:
erwin.coumans
@@ -27,6 +27,10 @@ ADD_EXECUTABLE(AppFractureDemo
|
||||
main.cpp
|
||||
FractureDemo.cpp
|
||||
FractureDemo.h
|
||||
btFractureBody.h
|
||||
btFractureBody.cpp
|
||||
btFractureDynamicsWorld.cpp
|
||||
btFractureDynamicsWorld.h
|
||||
${BULLET_PHYSICS_SOURCE_DIR}/msvc/bullet.rc
|
||||
)
|
||||
ELSE()
|
||||
@@ -34,6 +38,10 @@ ELSE()
|
||||
main.cpp
|
||||
FractureDemo.cpp
|
||||
FractureDemo.h
|
||||
btFractureBody.h
|
||||
btFractureBody.cpp
|
||||
btFractureDynamicsWorld.cpp
|
||||
btFractureDynamicsWorld.h
|
||||
)
|
||||
ENDIF()
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
138
Demos/FractureDemo/btFractureBody.cpp
Normal file
138
Demos/FractureDemo/btFractureBody.cpp
Normal file
@@ -0,0 +1,138 @@
|
||||
|
||||
#include "btFractureBody.h"
|
||||
#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
|
||||
#include "BulletCollision/CollisionShapes/btCompoundShape.h"
|
||||
#include "BulletDynamics/Dynamics/btDynamicsWorld.h"
|
||||
|
||||
|
||||
|
||||
void btFractureBody::recomputeConnectivity(btCollisionWorld* world)
|
||||
{
|
||||
m_connections.clear();
|
||||
//@todo use the AABB tree to avoid N^2 checks
|
||||
|
||||
if (getCollisionShape()->isCompound())
|
||||
{
|
||||
btCompoundShape* compound = (btCompoundShape*)getCollisionShape();
|
||||
for (int i=0;i<compound->getNumChildShapes();i++)
|
||||
{
|
||||
for (int j=i+1;j<compound->getNumChildShapes();j++)
|
||||
{
|
||||
|
||||
struct MyContactResultCallback : public btCollisionWorld::ContactResultCallback
|
||||
{
|
||||
bool m_connected;
|
||||
MyContactResultCallback() :m_connected(false)
|
||||
{
|
||||
}
|
||||
virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1)
|
||||
{
|
||||
//@todo additional check on cp?
|
||||
m_connected = true;
|
||||
return 1.f;
|
||||
}
|
||||
};
|
||||
|
||||
MyContactResultCallback result;
|
||||
|
||||
btCollisionObject obA;
|
||||
obA.setWorldTransform(compound->getChildTransform(i));
|
||||
obA.setCollisionShape(compound->getChildShape(i));
|
||||
btCollisionObject obB;
|
||||
obB.setWorldTransform(compound->getChildTransform(j));
|
||||
obB.setCollisionShape(compound->getChildShape(j));
|
||||
world->contactPairTest(&obA,&obB,result);
|
||||
if (result.m_connected)
|
||||
{
|
||||
btConnection tmp;
|
||||
tmp.m_childIndex0 = i;
|
||||
tmp.m_childIndex1 = j;
|
||||
tmp.m_childShape0 = compound->getChildShape(i);
|
||||
tmp.m_childShape1 = compound->getChildShape(j);
|
||||
tmp.m_strength = 1.f;//??
|
||||
m_connections.push_back(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
btCompoundShape* btFractureBody::shiftTransformDistributeMass(btCompoundShape* boxCompound,btScalar mass,btTransform& shift)
|
||||
{
|
||||
|
||||
btVector3 principalInertia;
|
||||
|
||||
btScalar* masses = new btScalar[boxCompound->getNumChildShapes()];
|
||||
for (int j=0;j<boxCompound->getNumChildShapes();j++)
|
||||
{
|
||||
//evenly distribute mass
|
||||
masses[j]=mass/boxCompound->getNumChildShapes();
|
||||
}
|
||||
|
||||
return shiftTransform(boxCompound,masses,shift,principalInertia);
|
||||
|
||||
}
|
||||
|
||||
|
||||
btCompoundShape* btFractureBody::shiftTransform(btCompoundShape* boxCompound,btScalar* masses,btTransform& shift, btVector3& principalInertia)
|
||||
{
|
||||
btTransform principal;
|
||||
|
||||
boxCompound->calculatePrincipalAxisTransform(masses,principal,principalInertia);
|
||||
|
||||
|
||||
///create a new compound with world transform/center of mass properly aligned with the principal axis
|
||||
|
||||
///non-recursive compound shapes perform better
|
||||
|
||||
#ifdef USE_RECURSIVE_COMPOUND
|
||||
|
||||
btCompoundShape* newCompound = new btCompoundShape();
|
||||
newCompound->addChildShape(principal.inverse(),boxCompound);
|
||||
newBoxCompound = newCompound;
|
||||
//m_collisionShapes.push_back(newCompound);
|
||||
|
||||
//btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
|
||||
//btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,newCompound,principalInertia);
|
||||
|
||||
#else
|
||||
#ifdef CHANGE_COMPOUND_INPLACE
|
||||
newBoxCompound = boxCompound;
|
||||
for (int i=0;i<boxCompound->getNumChildShapes();i++)
|
||||
{
|
||||
btTransform newChildTransform = principal.inverse()*boxCompound->getChildTransform(i);
|
||||
///updateChildTransform is really slow, because it re-calculates the AABB each time. todo: add option to disable this update
|
||||
boxCompound->updateChildTransform(i,newChildTransform);
|
||||
}
|
||||
bool isDynamic = (mass != 0.f);
|
||||
btVector3 localInertia(0,0,0);
|
||||
if (isDynamic)
|
||||
boxCompound->calculateLocalInertia(mass,localInertia);
|
||||
|
||||
#else
|
||||
///creation is faster using a new compound to store the shifted children
|
||||
btCompoundShape* newBoxCompound = new btCompoundShape();
|
||||
for (int i=0;i<boxCompound->getNumChildShapes();i++)
|
||||
{
|
||||
btTransform newChildTransform = principal.inverse()*boxCompound->getChildTransform(i);
|
||||
///updateChildTransform is really slow, because it re-calculates the AABB each time. todo: add option to disable this update
|
||||
newBoxCompound->addChildShape(newChildTransform,boxCompound->getChildShape(i));
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
#endif//USE_RECURSIVE_COMPOUND
|
||||
|
||||
shift = principal;
|
||||
return newBoxCompound;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
78
Demos/FractureDemo/btFractureBody.h
Normal file
78
Demos/FractureDemo/btFractureBody.h
Normal file
@@ -0,0 +1,78 @@
|
||||
|
||||
#ifndef BT_FRACTURE_BODY
|
||||
#define BT_FRACTURE_BODY
|
||||
|
||||
class btCollisionShape;
|
||||
class btDynamicsWorld;
|
||||
class btCollisionWorld;
|
||||
class btCompoundShape;
|
||||
class btManifoldPoint;
|
||||
|
||||
#include "LinearMath/btAlignedObjectArray.h"
|
||||
#include "BulletDynamics/Dynamics/btRigidBody.h"
|
||||
|
||||
#define CUSTOM_FRACTURE_TYPE (btRigidBody::CO_USER_TYPE+1)
|
||||
|
||||
|
||||
struct btConnection
|
||||
{
|
||||
|
||||
btCollisionShape* m_childShape0;
|
||||
btCollisionShape* m_childShape1;
|
||||
int m_childIndex0;
|
||||
int m_childIndex1;
|
||||
btScalar m_strength;
|
||||
};
|
||||
|
||||
class btFractureBody : public btRigidBody
|
||||
{
|
||||
//connections
|
||||
public:
|
||||
|
||||
btDynamicsWorld* m_world;
|
||||
btAlignedObjectArray<btScalar> m_masses;
|
||||
btAlignedObjectArray<btConnection> m_connections;
|
||||
|
||||
|
||||
|
||||
btFractureBody( const btRigidBodyConstructionInfo& constructionInfo, btDynamicsWorld* world)
|
||||
:btRigidBody(constructionInfo),
|
||||
m_world(world)
|
||||
{
|
||||
m_masses.push_back(constructionInfo.m_mass);
|
||||
m_internalType=CUSTOM_FRACTURE_TYPE+CO_RIGID_BODY;
|
||||
}
|
||||
|
||||
|
||||
|
||||
///btRigidBody constructor for backwards compatibility.
|
||||
///To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo)
|
||||
btFractureBody( btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia, btScalar* masses, int numMasses, btDynamicsWorld* world)
|
||||
:btRigidBody(mass,motionState,collisionShape,localInertia),
|
||||
m_world(world)
|
||||
{
|
||||
|
||||
for (int i=0;i<numMasses;i++)
|
||||
m_masses.push_back(masses[i]);
|
||||
|
||||
m_internalType=CUSTOM_FRACTURE_TYPE+CO_RIGID_BODY;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void recomputeConnectivity(btCollisionWorld* world);
|
||||
|
||||
|
||||
static btCompoundShape* shiftTransform(btCompoundShape* boxCompound,btScalar* masses,btTransform& shift, btVector3& principalInertia);
|
||||
|
||||
static btCompoundShape* shiftTransformDistributeMass(btCompoundShape* boxCompound,btScalar mass,btTransform& shift);
|
||||
|
||||
static bool collisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0,int partId0,int index0,const btCollisionObject* colObj1,int partId1,int index1);
|
||||
|
||||
};
|
||||
|
||||
|
||||
void fractureCallback(btDynamicsWorld* world, btScalar timeStep);
|
||||
void glueCallback(btDynamicsWorld* world, btScalar timeStep);
|
||||
|
||||
#endif //BT_FRACTURE_BODY
|
||||
636
Demos/FractureDemo/btFractureDynamicsWorld.cpp
Normal file
636
Demos/FractureDemo/btFractureDynamicsWorld.cpp
Normal file
@@ -0,0 +1,636 @@
|
||||
|
||||
#include "btFractureDynamicsWorld.h"
|
||||
#include "btFractureBody.h"
|
||||
#include "BulletCollision/CollisionShapes/btCompoundShape.h"
|
||||
|
||||
#include "BulletCollision/CollisionDispatch/btUnionFind.h"
|
||||
|
||||
btFractureDynamicsWorld::btFractureDynamicsWorld ( btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration)
|
||||
:btDiscreteDynamicsWorld(dispatcher,pairCache,constraintSolver,collisionConfiguration),
|
||||
m_fracturingMode(false)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
void btFractureDynamicsWorld::glueCallback(btScalar timeStep)
|
||||
{
|
||||
|
||||
int numManifolds = getDispatcher()->getNumManifolds();
|
||||
|
||||
btUnionFind unionFind;
|
||||
|
||||
int index = 0;
|
||||
{
|
||||
|
||||
int i;
|
||||
for (i=0;i<getCollisionObjectArray().size(); i++)
|
||||
{
|
||||
btCollisionObject* collisionObject= getCollisionObjectArray()[i];
|
||||
btRigidBody* body = btRigidBody::upcast(collisionObject);
|
||||
//Adding filtering here
|
||||
#ifdef STATIC_SIMULATION_ISLAND_OPTIMIZATION
|
||||
if (!collisionObject->isStaticOrKinematicObject())
|
||||
{
|
||||
collisionObject->setIslandTag(index++);
|
||||
} else
|
||||
{
|
||||
collisionObject->setIslandTag(-1);
|
||||
}
|
||||
#else
|
||||
collisionObject->setIslandTag(i);
|
||||
index=i+1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
unionFind.reset(index);
|
||||
|
||||
int numElem = unionFind.getNumElements();
|
||||
|
||||
for (int i=0;i<numManifolds;i++)
|
||||
{
|
||||
btPersistentManifold* manifold = getDispatcher()->getManifoldByIndexInternal(i);
|
||||
if (!manifold->getNumContacts())
|
||||
continue;
|
||||
|
||||
btCollisionObject* colObj0 = (btCollisionObject*)manifold->getBody0();
|
||||
btCollisionObject* colObj1 = (btCollisionObject*)manifold->getBody1();
|
||||
int tag0 = (colObj0)->getIslandTag();
|
||||
int tag1 = (colObj1)->getIslandTag();
|
||||
btRigidBody* body0 = btRigidBody::upcast(colObj0);
|
||||
btRigidBody* body1 = btRigidBody::upcast(colObj1);
|
||||
|
||||
|
||||
if (!colObj0->isStaticOrKinematicObject() && !colObj1->isStaticOrKinematicObject())
|
||||
{
|
||||
unionFind.unite(tag0, tag1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
numElem = unionFind.getNumElements();
|
||||
|
||||
|
||||
|
||||
index=0;
|
||||
for (int ai=0;ai<getCollisionObjectArray().size();ai++)
|
||||
{
|
||||
btCollisionObject* collisionObject= getCollisionObjectArray()[ai];
|
||||
if (!collisionObject->isStaticOrKinematicObject())
|
||||
{
|
||||
int tag = unionFind.find(index);
|
||||
|
||||
collisionObject->setIslandTag( tag);
|
||||
|
||||
//Set the correct object offset in Collision Object Array
|
||||
#if STATIC_SIMULATION_ISLAND_OPTIMIZATION
|
||||
unionFind.getElement(index).m_sz = ai;
|
||||
#endif //STATIC_SIMULATION_ISLAND_OPTIMIZATION
|
||||
|
||||
index++;
|
||||
}
|
||||
}
|
||||
unionFind.sortIslands();
|
||||
|
||||
|
||||
|
||||
int endIslandIndex=1;
|
||||
int startIslandIndex;
|
||||
|
||||
btAlignedObjectArray<btCollisionObject*> removedObjects;
|
||||
|
||||
//update the sleeping state for bodies, if all are sleeping
|
||||
for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
|
||||
{
|
||||
int islandId = unionFind.getElement(startIslandIndex).m_id;
|
||||
for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (unionFind.getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
|
||||
{
|
||||
}
|
||||
|
||||
int fractureObjectIndex = -1;
|
||||
|
||||
int numObjects=0;
|
||||
|
||||
int idx;
|
||||
for (idx=startIslandIndex;idx<endIslandIndex;idx++)
|
||||
{
|
||||
int i = unionFind.getElement(idx).m_sz;
|
||||
btCollisionObject* colObj0 = getCollisionObjectArray()[i];
|
||||
if (colObj0->getInternalType()& CUSTOM_FRACTURE_TYPE)
|
||||
{
|
||||
fractureObjectIndex = i;
|
||||
}
|
||||
btRigidBody* otherObject = btRigidBody::upcast(colObj0);
|
||||
if (!otherObject || !otherObject->getInvMass())
|
||||
continue;
|
||||
numObjects++;
|
||||
}
|
||||
|
||||
|
||||
if (fractureObjectIndex>=0 && numObjects>1)
|
||||
{
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
btFractureBody* fracObj = (btFractureBody*)getCollisionObjectArray()[fractureObjectIndex];
|
||||
|
||||
removedObjects.push_back(fracObj);
|
||||
m_fractureBodies.remove(fracObj);
|
||||
|
||||
btAlignedObjectArray<btScalar> massArray;
|
||||
btScalar totalMass = 0.f;
|
||||
|
||||
|
||||
btCompoundShape* compound = new btCompoundShape();
|
||||
if (fracObj->getCollisionShape()->isCompound())
|
||||
{
|
||||
btTransform tr;
|
||||
tr.setIdentity();
|
||||
btCompoundShape* oldCompound = (btCompoundShape*)fracObj->getCollisionShape();
|
||||
for (int c=0;c<oldCompound->getNumChildShapes();c++)
|
||||
{
|
||||
compound->addChildShape(oldCompound->getChildTransform(c),oldCompound->getChildShape(c));
|
||||
massArray.push_back(fracObj->m_masses[c]);
|
||||
totalMass+=fracObj->m_masses[c];
|
||||
}
|
||||
|
||||
} else
|
||||
{
|
||||
btTransform tr;
|
||||
tr.setIdentity();
|
||||
compound->addChildShape(tr,fracObj->getCollisionShape());
|
||||
massArray.push_back(fracObj->m_masses[0]);
|
||||
totalMass+=fracObj->m_masses[0];
|
||||
}
|
||||
|
||||
for (idx=startIslandIndex;idx<endIslandIndex;idx++)
|
||||
{
|
||||
|
||||
int i = unionFind.getElement(idx).m_sz;
|
||||
|
||||
if (i==fractureObjectIndex)
|
||||
continue;
|
||||
|
||||
btCollisionObject* otherCollider = getCollisionObjectArray()[i];
|
||||
|
||||
btRigidBody* otherObject = btRigidBody::upcast(otherCollider);
|
||||
if (!otherObject || !otherObject->getInvMass())
|
||||
continue;
|
||||
|
||||
removedObjects.push_back(otherObject);
|
||||
m_fractureBodies.remove((btFractureBody*)otherObject);
|
||||
|
||||
btScalar curMass = 1.f/otherObject->getInvMass();
|
||||
|
||||
|
||||
if (otherObject->getCollisionShape()->isCompound())
|
||||
{
|
||||
btTransform tr;
|
||||
btCompoundShape* oldCompound = (btCompoundShape*)otherObject->getCollisionShape();
|
||||
for (int c=0;c<oldCompound->getNumChildShapes();c++)
|
||||
{
|
||||
tr = fracObj->getWorldTransform().inverseTimes(otherObject->getWorldTransform()*oldCompound->getChildTransform(c));
|
||||
compound->addChildShape(tr,oldCompound->getChildShape(c));
|
||||
massArray.push_back(curMass/(btScalar)oldCompound->getNumChildShapes());
|
||||
|
||||
}
|
||||
} else
|
||||
{
|
||||
btTransform tr;
|
||||
tr = fracObj->getWorldTransform().inverseTimes(otherObject->getWorldTransform());
|
||||
compound->addChildShape(tr,otherObject->getCollisionShape());
|
||||
massArray.push_back(curMass);
|
||||
}
|
||||
totalMass+=curMass;
|
||||
}
|
||||
|
||||
|
||||
|
||||
btTransform shift;
|
||||
shift.setIdentity();
|
||||
btCompoundShape* newCompound = btFractureBody::shiftTransformDistributeMass(compound,totalMass,shift);
|
||||
int numChildren = newCompound->getNumChildShapes();
|
||||
btAssert(numChildren == massArray.size());
|
||||
|
||||
btVector3 localInertia;
|
||||
newCompound->calculateLocalInertia(totalMass,localInertia);
|
||||
btFractureBody* newBody = new btFractureBody(totalMass,0,newCompound,localInertia, &massArray[0], numChildren,this);
|
||||
newBody->recomputeConnectivity(this);
|
||||
newBody->setWorldTransform(fracObj->getWorldTransform()*shift);
|
||||
addRigidBody(newBody);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
//remove the objects from the world at the very end,
|
||||
//otherwise the island tags would not match the world collision object array indices anymore
|
||||
while (removedObjects.size())
|
||||
{
|
||||
btCollisionObject* otherCollider = removedObjects[removedObjects.size()-1];
|
||||
removedObjects.pop_back();
|
||||
|
||||
btRigidBody* otherObject = btRigidBody::upcast(otherCollider);
|
||||
if (!otherObject || !otherObject->getInvMass())
|
||||
continue;
|
||||
removeRigidBody(otherObject);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
struct btFracturePair
|
||||
{
|
||||
btFractureBody* m_fracObj;
|
||||
btAlignedObjectArray<btPersistentManifold*> m_contactManifolds;
|
||||
};
|
||||
|
||||
|
||||
|
||||
void btFractureDynamicsWorld::solveConstraints(btContactSolverInfo& solverInfo)
|
||||
{
|
||||
//todo: add some logic
|
||||
|
||||
// save all velocities
|
||||
// 1) that if a fracture object break
|
||||
// 2) revert all velocties
|
||||
// 3) apply impulses for the fracture bodies at the contact locations
|
||||
// 4)and run the constaint solver again
|
||||
|
||||
btDiscreteDynamicsWorld::solveConstraints(solverInfo);
|
||||
|
||||
fractureCallback(solverInfo.m_timeStep);
|
||||
}
|
||||
|
||||
|
||||
void btFractureDynamicsWorld::addNewBody(const btTransform& oldTransform,btScalar* masses, btCompoundShape* oldCompound)
|
||||
{
|
||||
int i;
|
||||
|
||||
btTransform shift;
|
||||
shift.setIdentity();
|
||||
btVector3 localInertia;
|
||||
btCompoundShape* newCompound = btFractureBody::shiftTransform(oldCompound,masses,shift,localInertia);
|
||||
btScalar totalMass = 0;
|
||||
for (i=0;i<newCompound->getNumChildShapes();i++)
|
||||
totalMass += masses[i];
|
||||
//newCompound->calculateLocalInertia(totalMass,localInertia);
|
||||
|
||||
btFractureBody* newBody = new btFractureBody(totalMass,0,newCompound,localInertia, masses,newCompound->getNumChildShapes(), this);
|
||||
newBody->recomputeConnectivity(this);
|
||||
|
||||
newBody->setCollisionFlags(newBody->getCollisionFlags()|btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
|
||||
newBody->setWorldTransform(oldTransform*shift);
|
||||
addRigidBody(newBody);
|
||||
}
|
||||
|
||||
void btFractureDynamicsWorld::addRigidBody(btRigidBody* body)
|
||||
{
|
||||
if (body->getInternalType() & CUSTOM_FRACTURE_TYPE)
|
||||
{
|
||||
btFractureBody* fbody = (btFractureBody*)body;
|
||||
m_fractureBodies.push_back(fbody);
|
||||
}
|
||||
btDiscreteDynamicsWorld::addRigidBody(body);
|
||||
}
|
||||
|
||||
void btFractureDynamicsWorld::removeRigidBody(btRigidBody* body)
|
||||
{
|
||||
if (body->getInternalType() & CUSTOM_FRACTURE_TYPE)
|
||||
{
|
||||
btFractureBody* fbody = (btFractureBody*)body;
|
||||
m_fractureBodies.remove(fbody);
|
||||
}
|
||||
btDiscreteDynamicsWorld::removeRigidBody(body);
|
||||
}
|
||||
|
||||
void btFractureDynamicsWorld::breakDisconnectedParts( btFractureBody* fracObj)
|
||||
{
|
||||
|
||||
if (!fracObj->getCollisionShape()->isCompound())
|
||||
return;
|
||||
|
||||
btCompoundShape* compound = (btCompoundShape*)fracObj->getCollisionShape();
|
||||
int numChildren = compound->getNumChildShapes();
|
||||
|
||||
if (numChildren<=1)
|
||||
return;
|
||||
|
||||
//compute connectivity
|
||||
btUnionFind unionFind;
|
||||
|
||||
btAlignedObjectArray<int> tags;
|
||||
tags.resize(numChildren);
|
||||
int i, index = 0;
|
||||
for ( i=0;i<numChildren;i++)
|
||||
{
|
||||
#ifdef STATIC_SIMULATION_ISLAND_OPTIMIZATION
|
||||
tags[i] = index++;
|
||||
#else
|
||||
tags[i] = i;
|
||||
index=i+1;
|
||||
#endif
|
||||
}
|
||||
|
||||
unionFind.reset(index);
|
||||
int numElem = unionFind.getNumElements();
|
||||
for (i=0;i<fracObj->m_connections.size();i++)
|
||||
{
|
||||
btConnection& connection = fracObj->m_connections[i];
|
||||
if (connection.m_strength > 0.)
|
||||
{
|
||||
int tag0 = tags[connection.m_childIndex0];
|
||||
int tag1 = tags[connection.m_childIndex1];
|
||||
unionFind.unite(tag0, tag1);
|
||||
}
|
||||
}
|
||||
numElem = unionFind.getNumElements();
|
||||
|
||||
index=0;
|
||||
for (int ai=0;ai<numChildren;ai++)
|
||||
{
|
||||
int tag = unionFind.find(index);
|
||||
tags[ai] = tag;
|
||||
//Set the correct object offset in Collision Object Array
|
||||
#if STATIC_SIMULATION_ISLAND_OPTIMIZATION
|
||||
unionFind.getElement(index).m_sz = ai;
|
||||
#endif //STATIC_SIMULATION_ISLAND_OPTIMIZATION
|
||||
index++;
|
||||
}
|
||||
unionFind.sortIslands();
|
||||
|
||||
int endIslandIndex=1;
|
||||
int startIslandIndex;
|
||||
|
||||
btAlignedObjectArray<btCollisionObject*> removedObjects;
|
||||
|
||||
int numIslands = 0;
|
||||
|
||||
for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
|
||||
{
|
||||
int islandId = unionFind.getElement(startIslandIndex).m_id;
|
||||
for (endIslandIndex = startIslandIndex+1;(endIslandIndex<numElem) && (unionFind.getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
|
||||
{
|
||||
}
|
||||
|
||||
int fractureObjectIndex = -1;
|
||||
|
||||
int numShapes=0;
|
||||
|
||||
|
||||
btCompoundShape* newCompound = new btCompoundShape();
|
||||
btAlignedObjectArray<btScalar> masses;
|
||||
|
||||
int idx;
|
||||
for (idx=startIslandIndex;idx<endIslandIndex;idx++)
|
||||
{
|
||||
int i = unionFind.getElement(idx).m_sz;
|
||||
btCollisionShape* shape = compound->getChildShape(i);
|
||||
newCompound->addChildShape(compound->getChildTransform(i),compound->getChildShape(i));
|
||||
masses.push_back(fracObj->m_masses[i]);
|
||||
numShapes++;
|
||||
}
|
||||
if (numShapes)
|
||||
{
|
||||
addNewBody(fracObj->getWorldTransform(),&masses[0],newCompound);
|
||||
numIslands++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
removeRigidBody(fracObj);//should it also be removed from the array?
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void btFractureDynamicsWorld::fractureCallback( btScalar timeStep)
|
||||
{
|
||||
|
||||
btAlignedObjectArray<btFracturePair> sFracturePairs;
|
||||
|
||||
if (!m_fracturingMode)
|
||||
{
|
||||
glueCallback(timeStep);
|
||||
return;
|
||||
}
|
||||
|
||||
int numManifolds = getDispatcher()->getNumManifolds();
|
||||
|
||||
sFracturePairs.clear();
|
||||
|
||||
|
||||
for (int i=0;i<numManifolds;i++)
|
||||
{
|
||||
btPersistentManifold* manifold = getDispatcher()->getManifoldByIndexInternal(i);
|
||||
if (!manifold->getNumContacts())
|
||||
continue;
|
||||
|
||||
btScalar totalImpact = 0.f;
|
||||
for (int p=0;p<manifold->getNumContacts();p++)
|
||||
{
|
||||
totalImpact += manifold->getContactPoint(p).m_appliedImpulse;
|
||||
}
|
||||
|
||||
static float maxImpact = 0;
|
||||
if (totalImpact>maxImpact)
|
||||
maxImpact = totalImpact;
|
||||
|
||||
//some threshold otherwise resting contact would break objects after a while
|
||||
if (totalImpact < 10)
|
||||
continue;
|
||||
|
||||
// printf("strong impact\n");
|
||||
|
||||
|
||||
//@todo: add better logic to decide what parts to fracture
|
||||
//For example use the idea from the SIGGRAPH talk about the fracture in the movie 2012:
|
||||
//
|
||||
//Breaking thresholds can be stored as connectivity information between child shapes in the fracture object
|
||||
//
|
||||
//You can calculate some "impact value" by simulating all the individual child shapes
|
||||
//as rigid bodies, without constraints, running it in a separate simulation world
|
||||
//(or by running the constraint solver without actually modifying the dynamics world)
|
||||
//Then measure some "impact value" using the offset and applied impulse for each child shape
|
||||
//weaken the connections based on this "impact value" and only break
|
||||
//if this impact value exceeds the breaking threshold.
|
||||
//you can propagate the weakening and breaking of connections using the connectivity information
|
||||
|
||||
int f0 = m_fractureBodies.findLinearSearch((btFractureBody*)manifold->getBody0());
|
||||
int f1 = m_fractureBodies.findLinearSearch((btFractureBody*)manifold->getBody1());
|
||||
|
||||
if (f0 == f1 == m_fractureBodies.size())
|
||||
continue;
|
||||
|
||||
|
||||
if (f0<m_fractureBodies.size())
|
||||
{
|
||||
int j=f0;
|
||||
|
||||
btCollisionObject* colOb = (btCollisionObject*)manifold->getBody1();
|
||||
btRigidBody* otherOb = btRigidBody::upcast(colOb);
|
||||
// if (!otherOb->getInvMass())
|
||||
// continue;
|
||||
|
||||
int pi=-1;
|
||||
|
||||
for (int p=0;p<sFracturePairs.size();p++)
|
||||
{
|
||||
if (sFracturePairs[p].m_fracObj == m_fractureBodies[j])
|
||||
{
|
||||
pi = p; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (pi<0)
|
||||
{
|
||||
btFracturePair p;
|
||||
p.m_fracObj = m_fractureBodies[j];
|
||||
p.m_contactManifolds.push_back(manifold);
|
||||
sFracturePairs.push_back(p);
|
||||
} else
|
||||
{
|
||||
btAssert(sFracturePairs[pi].m_contactManifolds.findLinearSearch(manifold)==sFracturePairs[pi].m_contactManifolds.size());
|
||||
sFracturePairs[pi].m_contactManifolds.push_back(manifold);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (f1 < m_fractureBodies.size())
|
||||
{
|
||||
int j=f1;
|
||||
{
|
||||
btCollisionObject* colOb = (btCollisionObject*)manifold->getBody0();
|
||||
btRigidBody* otherOb = btRigidBody::upcast(colOb);
|
||||
// if (!otherOb->getInvMass())
|
||||
// continue;
|
||||
|
||||
|
||||
int pi=-1;
|
||||
|
||||
for (int p=0;p<sFracturePairs.size();p++)
|
||||
{
|
||||
if (sFracturePairs[p].m_fracObj == m_fractureBodies[j])
|
||||
{
|
||||
pi = p; break;
|
||||
}
|
||||
}
|
||||
if (pi<0)
|
||||
{
|
||||
btFracturePair p;
|
||||
p.m_fracObj = m_fractureBodies[j];
|
||||
p.m_contactManifolds.push_back( manifold);
|
||||
sFracturePairs.push_back(p);
|
||||
} else
|
||||
{
|
||||
btAssert(sFracturePairs[pi].m_contactManifolds.findLinearSearch(manifold)==sFracturePairs[pi].m_contactManifolds.size());
|
||||
sFracturePairs[pi].m_contactManifolds.push_back(manifold);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
}
|
||||
|
||||
//printf("m_fractureBodies size=%d\n",m_fractureBodies.size());
|
||||
//printf("sFracturePairs size=%d\n",sFracturePairs.size());
|
||||
if (!sFracturePairs.size())
|
||||
return;
|
||||
|
||||
|
||||
{
|
||||
// printf("fracturing\n");
|
||||
|
||||
for (int i=0;i<sFracturePairs.size();i++)
|
||||
{
|
||||
//check impulse/displacement at impact
|
||||
|
||||
//weaken/break connections (and propagate breaking)
|
||||
|
||||
//compute connectivity of connected child shapes
|
||||
|
||||
|
||||
if (sFracturePairs[i].m_fracObj->getCollisionShape()->isCompound())
|
||||
{
|
||||
btTransform tr;
|
||||
tr.setIdentity();
|
||||
btCompoundShape* oldCompound = (btCompoundShape*)sFracturePairs[i].m_fracObj->getCollisionShape();
|
||||
if (oldCompound->getNumChildShapes()>1)
|
||||
{
|
||||
bool needsBreakingCheck = false;
|
||||
|
||||
|
||||
//weaken/break the connections
|
||||
|
||||
//@todo: propagate along the connection graph
|
||||
for (int j=0;j<sFracturePairs[i].m_contactManifolds.size();j++)
|
||||
{
|
||||
btPersistentManifold* manifold = sFracturePairs[i].m_contactManifolds[j];
|
||||
for (int k=0;k<manifold->getNumContacts();k++)
|
||||
{
|
||||
btManifoldPoint& pt = manifold->getContactPoint(k);
|
||||
if (manifold->getBody0()==sFracturePairs[i].m_fracObj)
|
||||
{
|
||||
for (int f=0;f<sFracturePairs[i].m_fracObj->m_connections.size();f++)
|
||||
{
|
||||
btConnection& connection = sFracturePairs[i].m_fracObj->m_connections[f];
|
||||
if ( (connection.m_childIndex0 == pt.m_index0) ||
|
||||
(connection.m_childIndex1 == pt.m_index0)
|
||||
)
|
||||
{
|
||||
connection.m_strength -= pt.m_appliedImpulse;
|
||||
if (connection.m_strength<0)
|
||||
{
|
||||
//remove or set to zero
|
||||
connection.m_strength=0.f;
|
||||
needsBreakingCheck = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
{
|
||||
for (int f=0;f<sFracturePairs[i].m_fracObj->m_connections.size();f++)
|
||||
{
|
||||
btConnection& connection = sFracturePairs[i].m_fracObj->m_connections[f];
|
||||
if ( (connection.m_childIndex0 == pt.m_index1) ||
|
||||
(connection.m_childIndex1 == pt.m_index1)
|
||||
)
|
||||
{
|
||||
connection.m_strength -= pt.m_appliedImpulse;
|
||||
if (connection.m_strength<0)
|
||||
{
|
||||
//remove or set to zero
|
||||
connection.m_strength=0.f;
|
||||
needsBreakingCheck = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (needsBreakingCheck)
|
||||
{
|
||||
breakDisconnectedParts(sFracturePairs[i].m_fracObj);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
sFracturePairs.clear();
|
||||
|
||||
}
|
||||
|
||||
48
Demos/FractureDemo/btFractureDynamicsWorld.h
Normal file
48
Demos/FractureDemo/btFractureDynamicsWorld.h
Normal file
@@ -0,0 +1,48 @@
|
||||
#ifndef _BT_FRACTURE_DYNAMICS_WORLD_H
|
||||
#define _BT_FRACTURE_DYNAMICS_WORLD_H
|
||||
|
||||
#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
|
||||
#include "LinearMath/btAlignedObjectArray.h"
|
||||
|
||||
class btFractureBody;
|
||||
class btCompoundShape;
|
||||
class btTransform;
|
||||
|
||||
|
||||
///The btFractureDynamicsWorld class enabled basic glue and fracture of objects.
|
||||
///If/once this implementation is stablized/tested we might merge it into btDiscreteDynamicsWorld and remove the class.
|
||||
class btFractureDynamicsWorld : public btDiscreteDynamicsWorld
|
||||
{
|
||||
btAlignedObjectArray<btFractureBody*> m_fractureBodies;
|
||||
|
||||
bool m_fracturingMode;
|
||||
|
||||
void glueCallback(btScalar timeStep);
|
||||
|
||||
void fractureCallback( btScalar timeStep);
|
||||
|
||||
void addNewBody(const btTransform& oldTransform,btScalar* masses, btCompoundShape* oldCompound);
|
||||
|
||||
void breakDisconnectedParts( btFractureBody* fracObj);
|
||||
|
||||
public:
|
||||
|
||||
btFractureDynamicsWorld ( btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration);
|
||||
|
||||
virtual void addRigidBody(btRigidBody* body);
|
||||
|
||||
virtual void removeRigidBody(btRigidBody* body);
|
||||
|
||||
void solveConstraints(btContactSolverInfo& solverInfo);
|
||||
|
||||
///either fracture or glue (!fracture)
|
||||
void setFractureMode(bool fracture)
|
||||
{
|
||||
m_fracturingMode = fracture;
|
||||
}
|
||||
|
||||
bool getFractureMode() const { return m_fracturingMode;}
|
||||
};
|
||||
|
||||
#endif //_BT_FRACTURE_DYNAMICS_WORLD_H
|
||||
|
||||
Reference in New Issue
Block a user