mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-13 13:20:07 +00:00
ab8f16961e
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files. make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type. This commit contains no other changes aside from adding and applying clang-format-all.sh
641 lines
19 KiB
C++
641 lines
19 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();
|
|
}
|