mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-14 13:50:04 +00:00
c0c4c8ba3f
remove btMultiSapBroadphase.* make collisionFilterGroup/collisionFilterMark int (instead of short int)
689 lines
18 KiB
C++
689 lines
18 KiB
C++
|
|
#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(true)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
void btFractureDynamicsWorld::glueCallback()
|
|
{
|
|
|
|
int numManifolds = getDispatcher()->getNumManifolds();
|
|
|
|
///first build the islands based on axis aligned bounding box overlap
|
|
|
|
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;
|
|
|
|
btScalar minDist = 1e30f;
|
|
for (int v=0;v<manifold->getNumContacts();v++)
|
|
{
|
|
minDist = btMin(minDist,manifold->getContactPoint(v).getDistance());
|
|
}
|
|
if (minDist>0.)
|
|
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;
|
|
|
|
///iterate over all islands
|
|
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++;
|
|
}
|
|
|
|
///Then for each island that contains at least two objects and one fracture object
|
|
if (fractureObjectIndex>=0 && numObjects>1)
|
|
{
|
|
|
|
btFractureBody* fracObj = (btFractureBody*)getCollisionObjectArray()[fractureObjectIndex];
|
|
|
|
///glueing objects means creating a new compound and removing the old objects
|
|
///delay the removal of old objects to avoid array indexing problems
|
|
removedObjects.push_back(fracObj);
|
|
m_fractureBodies.remove(fracObj);
|
|
|
|
btAlignedObjectArray<btScalar> massArray;
|
|
|
|
btAlignedObjectArray<btVector3> oldImpulses;
|
|
btAlignedObjectArray<btVector3> oldCenterOfMassesWS;
|
|
|
|
oldImpulses.push_back(fracObj->getLinearVelocity()/1./fracObj->getInvMass());
|
|
oldCenterOfMassesWS.push_back(fracObj->getCenterOfMassPosition());
|
|
|
|
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);
|
|
//don't glue/merge with static objects right now, otherwise everything gets stuck to the ground
|
|
///todo: expose this as a callback
|
|
if (!otherObject || !otherObject->getInvMass())
|
|
continue;
|
|
|
|
|
|
oldImpulses.push_back(otherObject->getLinearVelocity()*(1.f/otherObject->getInvMass()));
|
|
oldCenterOfMassesWS.push_back(otherObject->getCenterOfMassPosition());
|
|
|
|
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);
|
|
|
|
//now the linear/angular velocity is still zero, apply the impulses
|
|
|
|
for (int i=0;i<oldImpulses.size();i++)
|
|
{
|
|
btVector3 rel_pos = oldCenterOfMassesWS[i]-newBody->getCenterOfMassPosition();
|
|
const btVector3& imp = oldImpulses[i];
|
|
newBody->applyImpulse(imp, rel_pos);
|
|
}
|
|
|
|
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: after fracture we should run the solver again for better realism
|
|
// for example
|
|
// save all velocities and if one or more objects fracture:
|
|
// 1) revert all velocties
|
|
// 2) apply impulses for the fracture bodies at the contact locations
|
|
// 3)and run the constaint solver again
|
|
|
|
btDiscreteDynamicsWorld::solveConstraints(solverInfo);
|
|
|
|
fractureCallback();
|
|
}
|
|
|
|
btFractureBody* 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);
|
|
return 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;
|
|
btAlignedObjectArray<btTypedConstraint*> tmpConstraints;
|
|
|
|
for (int i=0;i<fbody->getNumConstraintRefs();i++)
|
|
{
|
|
tmpConstraints.push_back(fbody->getConstraintRef(i));
|
|
}
|
|
|
|
//remove all constraints attached to this rigid body too
|
|
for (int i=0;i<tmpConstraints.size();i++)
|
|
btDiscreteDynamicsWorld::removeConstraint(tmpConstraints[i]);
|
|
|
|
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)
|
|
{
|
|
btFractureBody* newBody = addNewBody(fracObj->getWorldTransform(),&masses[0],newCompound);
|
|
newBody->setLinearVelocity(fracObj->getLinearVelocity());
|
|
newBody->setAngularVelocity(fracObj->getAngularVelocity());
|
|
|
|
numIslands++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
removeRigidBody(fracObj);//should it also be removed from the array?
|
|
|
|
|
|
}
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
void btFractureDynamicsWorld::fractureCallback( )
|
|
{
|
|
|
|
btAlignedObjectArray<btFracturePair> sFracturePairs;
|
|
|
|
if (!m_fracturingMode)
|
|
{
|
|
glueCallback();
|
|
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;
|
|
}
|
|
|
|
|
|
// printf("totalImpact=%f\n",totalImpact);
|
|
|
|
static float maxImpact = 0;
|
|
if (totalImpact>maxImpact)
|
|
maxImpact = totalImpact;
|
|
|
|
//some threshold otherwise resting contact would break objects after a while
|
|
if (totalImpact < 40.f)
|
|
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();
|
|
|
|
}
|
|
|