Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Code-style consistency improvement:

Browse Source 
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
This commit is contained in:
erwincoumans
2018-09-23 14:17:31 -07:00
parent b73b05e9fb
commit ab8f16961e
1773 changed files with 1081087 additions and 474249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

310
examples/FractureDemo/btFractureDynamicsWorld.cpp
View File

@@ -5,17 +5,14 @@
#include "BulletCollision/CollisionDispatch/btUnionFind.h"
btFractureDynamicsWorld::btFractureDynamicsWorld ( btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration)
:btDiscreteDynamicsWorld(dispatcher,pairCache,constraintSolver,collisionConfiguration),
m_fracturingMode(true)
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
@@ -24,24 +21,24 @@ void btFractureDynamicsWorld::glueCallback()
int index = 0;
{
int i;
for (i=0;i<getCollisionObjectArray().size(); i++)
for (i = 0; i < getCollisionObjectArray().size(); i++)
{
btCollisionObject* collisionObject= getCollisionObjectArray()[i];
// btRigidBody* body = btRigidBody::upcast(collisionObject);
btCollisionObject* collisionObject = getCollisionObjectArray()[i];
// btRigidBody* body = btRigidBody::upcast(collisionObject);
//Adding filtering here
#ifdef STATIC_SIMULATION_ISLAND_OPTIMIZATION
if (!collisionObject->isStaticOrKinematicObject())
{
collisionObject->setIslandTag(index++);
} else
}
else
{
collisionObject->setIslandTag(-1);
}
#else
collisionObject->setIslandTag(i);
index=i+1;
index = i + 1;
#endif
}
}
@@ -50,20 +47,20 @@ void btFractureDynamicsWorld::glueCallback()
int numElem = unionFind.getNumElements();
for (int i=0;i<numManifolds;i++)
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++)
for (int v = 0; v < manifold->getNumContacts(); v++)
{
minDist = btMin(minDist,manifold->getContactPoint(v).getDistance());
minDist = btMin(minDist, manifold->getContactPoint(v).getDistance());
}
if (minDist>0.)
if (minDist > 0.)
continue;
btCollisionObject* colObj0 = (btCollisionObject*)manifold->getBody0();
btCollisionObject* colObj1 = (btCollisionObject*)manifold->getBody1();
int tag0 = (colObj0)->getIslandTag();
@@ -71,65 +68,57 @@ void btFractureDynamicsWorld::glueCallback()
//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++)
index = 0;
for (int ai = 0; ai < getCollisionObjectArray().size(); ai++)
{
btCollisionObject* collisionObject= getCollisionObjectArray()[ai];
btCollisionObject* collisionObject = getCollisionObjectArray()[ai];
if (!collisionObject->isStaticOrKinematicObject())
{
int tag = unionFind.find(index);
collisionObject->setIslandTag( tag);
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
#endif //STATIC_SIMULATION_ISLAND_OPTIMIZATION
index++;
}
}
unionFind.sortIslands();
int endIslandIndex=1;
int endIslandIndex = 1;
int startIslandIndex;
btAlignedObjectArray<btCollisionObject*> removedObjects;
///iterate over all islands
for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
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++)
for (endIslandIndex = startIslandIndex + 1; (endIslandIndex < numElem) && (unionFind.getElement(endIslandIndex).m_id == islandId); endIslandIndex++)
{
}
int fractureObjectIndex = -1;
int numObjects=0;
int numObjects = 0;
int idx;
for (idx=startIslandIndex;idx<endIslandIndex;idx++)
for (idx = startIslandIndex; idx < endIslandIndex; idx++)
{
int i = unionFind.getElement(idx).m_sz;
btCollisionObject* colObj0 = getCollisionObjectArray()[i];
if (colObj0->getInternalType()& CUSTOM_FRACTURE_TYPE)
if (colObj0->getInternalType() & CUSTOM_FRACTURE_TYPE)
{
fractureObjectIndex = i;
}
@@ -140,9 +129,8 @@ void btFractureDynamicsWorld::glueCallback()
}
///Then for each island that contains at least two objects and one fracture object
if (fractureObjectIndex>=0 && numObjects>1)
if (fractureObjectIndex >= 0 && numObjects > 1)
{
btFractureBody* fracObj = (btFractureBody*)getCollisionObjectArray()[fractureObjectIndex];
///glueing objects means creating a new compound and removing the old objects
@@ -155,40 +143,38 @@ void btFractureDynamicsWorld::glueCallback()
btAlignedObjectArray<btVector3> oldImpulses;
btAlignedObjectArray<btVector3> oldCenterOfMassesWS;
oldImpulses.push_back(fracObj->getLinearVelocity()/1./fracObj->getInvMass());
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++)
for (int c = 0; c < oldCompound->getNumChildShapes(); c++)
{
compound->addChildShape(oldCompound->getChildTransform(c),oldCompound->getChildShape(c));
compound->addChildShape(oldCompound->getChildTransform(c), oldCompound->getChildShape(c));
massArray.push_back(fracObj->m_masses[c]);
totalMass+=fracObj->m_masses[c];
totalMass += fracObj->m_masses[c];
}
} else
}
else
{
btTransform tr;
tr.setIdentity();
compound->addChildShape(tr,fracObj->getCollisionShape());
compound->addChildShape(tr, fracObj->getCollisionShape());
massArray.push_back(fracObj->m_masses[0]);
totalMass+=fracObj->m_masses[0];
totalMass += fracObj->m_masses[0];
}
for (idx=startIslandIndex;idx<endIslandIndex;idx++)
for (idx = startIslandIndex; idx < endIslandIndex; idx++)
{
int i = unionFind.getElement(idx).m_sz;
if (i==fractureObjectIndex)
if (i == fractureObjectIndex)
continue;
btCollisionObject* otherCollider = getCollisionObjectArray()[i];
@@ -199,73 +185,65 @@ void btFractureDynamicsWorld::glueCallback()
if (!otherObject || !otherObject->getInvMass())
continue;
oldImpulses.push_back(otherObject->getLinearVelocity()*(1.f/otherObject->getInvMass()));
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();
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++)
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());
tr = fracObj->getWorldTransform().inverseTimes(otherObject->getWorldTransform() * oldCompound->getChildTransform(c));
compound->addChildShape(tr, oldCompound->getChildShape(c));
massArray.push_back(curMass / (btScalar)oldCompound->getNumChildShapes());
}
} else
}
else
{
btTransform tr;
tr = fracObj->getWorldTransform().inverseTimes(otherObject->getWorldTransform());
compound->addChildShape(tr,otherObject->getCollisionShape());
compound->addChildShape(tr, otherObject->getCollisionShape());
massArray.push_back(curMass);
}
totalMass+=curMass;
totalMass += curMass;
}
btTransform shift;
shift.setIdentity();
btCompoundShape* newCompound = btFractureBody::shiftTransformDistributeMass(compound,totalMass,shift);
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);
newCompound->calculateLocalInertia(totalMass, localInertia);
btFractureBody* newBody = new btFractureBody(totalMass, 0, newCompound, localInertia, &massArray[0], numChildren, this);
newBody->recomputeConnectivity(this);
newBody->setWorldTransform(fracObj->getWorldTransform()*shift);
newBody->setWorldTransform(fracObj->getWorldTransform() * shift);
//now the linear/angular velocity is still zero, apply the impulses
for (int i=0;i<oldImpulses.size();i++)
for (int i = 0; i < oldImpulses.size(); i++)
{
btVector3 rel_pos = oldCenterOfMassesWS[i]-newBody->getCenterOfMassPosition();
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,
//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];
btCollisionObject* otherCollider = removedObjects[removedObjects.size() - 1];
removedObjects.pop_back();
btRigidBody* otherObject = btRigidBody::upcast(otherCollider);
@@ -273,18 +251,14 @@ void btFractureDynamicsWorld::glueCallback()
continue;
removeRigidBody(otherObject);
}
}
struct btFracturePair
struct btFracturePair
{
btFractureBody* m_fracObj;
btAlignedObjectArray<btPersistentManifold*> m_contactManifolds;
btAlignedObjectArray<btPersistentManifold*> m_contactManifolds;
};
void btFractureDynamicsWorld::solveConstraints(btContactSolverInfo& solverInfo)
{
// todo: after fracture we should run the solver again for better realism
@@ -299,24 +273,24 @@ void btFractureDynamicsWorld::solveConstraints(btContactSolverInfo& solverInfo)
fractureCallback();
}
btFractureBody* btFractureDynamicsWorld::addNewBody(const btTransform& oldTransform,btScalar* masses, btCompoundShape* oldCompound)
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);
btCompoundShape* newCompound = btFractureBody::shiftTransform(oldCompound, masses, shift, localInertia);
btScalar totalMass = 0;
for (i=0;i<newCompound->getNumChildShapes();i++)
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);
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);
newBody->setCollisionFlags(newBody->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
newBody->setWorldTransform(oldTransform * shift);
addRigidBody(newBody);
return newBody;
}
@@ -331,40 +305,37 @@ void btFractureDynamicsWorld::addRigidBody(btRigidBody* body)
btDiscreteDynamicsWorld::addRigidBody(body);
}
void btFractureDynamicsWorld::removeRigidBody(btRigidBody* 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++)
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++)
//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)
void btFractureDynamicsWorld::breakDisconnectedParts(btFractureBody* fracObj)
{
if (!fracObj->getCollisionShape()->isCompound())
return;
btCompoundShape* compound = (btCompoundShape*)fracObj->getCollisionShape();
int numChildren = compound->getNumChildShapes();
if (numChildren<=1)
if (numChildren <= 1)
return;
//compute connectivity
@@ -373,19 +344,19 @@ void btFractureDynamicsWorld::breakDisconnectedParts( btFractureBody* fracObj)
btAlignedObjectArray<int> tags;
tags.resize(numChildren);
int i, index = 0;
for ( i=0;i<numChildren;i++)
for (i = 0; i < numChildren; i++)
{
#ifdef STATIC_SIMULATION_ISLAND_OPTIMIZATION
tags[i] = index++;
#else
tags[i] = i;
index=i+1;
index = i + 1;
#endif
}
unionFind.reset(index);
int numElem = unionFind.getNumElements();
for (i=0;i<fracObj->m_connections.size();i++)
for (i = 0; i < fracObj->m_connections.size(); i++)
{
btConnection& connection = fracObj->m_connections[i];
if (connection.m_strength > 0.)
@@ -397,53 +368,52 @@ void btFractureDynamicsWorld::breakDisconnectedParts( btFractureBody* fracObj)
}
numElem = unionFind.getNumElements();
index=0;
for (int ai=0;ai<numChildren;ai++)
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
#endif //STATIC_SIMULATION_ISLAND_OPTIMIZATION
index++;
}
unionFind.sortIslands();
int endIslandIndex=1;
int endIslandIndex = 1;
int startIslandIndex;
btAlignedObjectArray<btCollisionObject*> removedObjects;
int numIslands = 0;
for ( startIslandIndex=0;startIslandIndex<numElem;startIslandIndex = endIslandIndex)
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++)
for (endIslandIndex = startIslandIndex + 1; (endIslandIndex < numElem) && (unionFind.getElement(endIslandIndex).m_id == islandId); endIslandIndex++)
{
}
// int fractureObjectIndex = -1;
int numShapes=0;
// int fractureObjectIndex = -1;
int numShapes = 0;
btCompoundShape* newCompound = new btCompoundShape();
btAlignedObjectArray<btScalar> masses;
int idx;
for (idx=startIslandIndex;idx<endIslandIndex;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));
// 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);
btFractureBody* newBody = addNewBody(fracObj->getWorldTransform(), &masses[0], newCompound);
newBody->setLinearVelocity(fracObj->getLinearVelocity());
newBody->setAngularVelocity(fracObj->getAngularVelocity());
@@ -451,21 +421,13 @@ void btFractureDynamicsWorld::breakDisconnectedParts( btFractureBody* fracObj)
}
}
removeRigidBody(fracObj);//should it also be removed from the array?
removeRigidBody(fracObj); //should it also be removed from the array?
}
#include <stdio.h>
void btFractureDynamicsWorld::fractureCallback( )
void btFractureDynamicsWorld::fractureCallback()
{
btAlignedObjectArray<btFracturePair> sFracturePairs;
if (!m_fracturingMode)
@@ -478,24 +440,22 @@ void btFractureDynamicsWorld::fractureCallback( )
sFracturePairs.clear();
for (int i=0;i<numManifolds;i++)
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++)
for (int p = 0; p < manifold->getNumContacts(); p++)
{
totalImpact += manifold->getContactPoint(p).m_appliedImpulse;
}
// printf("totalImpact=%f\n",totalImpact);
// printf("totalImpact=%f\n",totalImpact);
static float maxImpact = 0;
if (totalImpact>maxImpact)
if (totalImpact > maxImpact)
maxImpact = totalImpact;
//some threshold otherwise resting contact would break objects after a while
@@ -504,17 +464,16 @@ void btFractureDynamicsWorld::fractureCallback( )
// 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
//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
//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
@@ -524,68 +483,69 @@ void btFractureDynamicsWorld::fractureCallback( )
if (f0 == f1 == m_fractureBodies.size())
continue;
if (f0<m_fractureBodies.size())
if (f0 < m_fractureBodies.size())
{
int j=f0;
int j = f0;
// btCollisionObject* colOb = (btCollisionObject*)manifold->getBody1();
// btRigidBody* otherOb = btRigidBody::upcast(colOb);
// btCollisionObject* colOb = (btCollisionObject*)manifold->getBody1();
// btRigidBody* otherOb = btRigidBody::upcast(colOb);
// if (!otherOb->getInvMass())
// continue;
int pi=-1;
int pi = -1;
for (int p=0;p<sFracturePairs.size();p++)
for (int p = 0; p < sFracturePairs.size(); p++)
{
if (sFracturePairs[p].m_fracObj == m_fractureBodies[j])
{
pi = p; break;
pi = p;
break;
}
}
if (pi<0)
if (pi < 0)
{
btFracturePair p;
p.m_fracObj = m_fractureBodies[j];
p.m_contactManifolds.push_back(manifold);
sFracturePairs.push_back(p);
} else
}
else
{
btAssert(sFracturePairs[pi].m_contactManifolds.findLinearSearch(manifold)==sFracturePairs[pi].m_contactManifolds.size());
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;
int j = f1;
{
//btCollisionObject* colOb = (btCollisionObject*)manifold->getBody0();
//btRigidBody* otherOb = btRigidBody::upcast(colOb);
// if (!otherOb->getInvMass())
// continue;
int pi = -1;
int pi=-1;
for (int p=0;p<sFracturePairs.size();p++)
for (int p = 0; p < sFracturePairs.size(); p++)
{
if (sFracturePairs[p].m_fracObj == m_fractureBodies[j])
{
pi = p; break;
pi = p;
break;
}
}
if (pi<0)
if (pi < 0)
{
btFracturePair p;
p.m_fracObj = m_fractureBodies[j];
p.m_contactManifolds.push_back( manifold);
p.m_contactManifolds.push_back(manifold);
sFracturePairs.push_back(p);
} else
}
else
{
btAssert(sFracturePairs[pi].m_contactManifolds.findLinearSearch(manifold)==sFracturePairs[pi].m_contactManifolds.size());
btAssert(sFracturePairs[pi].m_contactManifolds.findLinearSearch(manifold) == sFracturePairs[pi].m_contactManifolds.size());
sFracturePairs[pi].m_contactManifolds.push_back(manifold);
}
}
@@ -599,11 +559,10 @@ void btFractureDynamicsWorld::fractureCallback( )
if (!sFracturePairs.size())
return;
{
// printf("fracturing\n");
for (int i=0;i<sFracturePairs.size();i++)
for (int i = 0; i < sFracturePairs.size(); i++)
{
//check impulse/displacement at impact
@@ -611,58 +570,55 @@ void btFractureDynamicsWorld::fractureCallback( )
//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)
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++)
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++)
for (int k = 0; k < manifold->getNumContacts(); k++)
{
btManifoldPoint& pt = manifold->getContactPoint(k);
if (manifold->getBody0()==sFracturePairs[i].m_fracObj)
if (manifold->getBody0() == sFracturePairs[i].m_fracObj)
{
for (int f=0;f<sFracturePairs[i].m_fracObj->m_connections.size();f++)
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)
)
if ((connection.m_childIndex0 == pt.m_index0) ||
(connection.m_childIndex1 == pt.m_index0))
{
connection.m_strength -= pt.m_appliedImpulse;
if (connection.m_strength<0)
if (connection.m_strength < 0)
{
//remove or set to zero
connection.m_strength=0.f;
connection.m_strength = 0.f;
needsBreakingCheck = true;
}
}
}
} else
}
else
{
for (int f=0;f<sFracturePairs[i].m_fracObj->m_connections.size();f++)
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)
)
if ((connection.m_childIndex0 == pt.m_index1) ||
(connection.m_childIndex1 == pt.m_index1))
{
connection.m_strength -= pt.m_appliedImpulse;
if (connection.m_strength<0)
if (connection.m_strength < 0)
{
//remove or set to zero
connection.m_strength=0.f;
connection.m_strength = 0.f;
needsBreakingCheck = true;
}
}
@@ -676,13 +632,9 @@ void btFractureDynamicsWorld::fractureCallback( )
breakDisconnectedParts(sFracturePairs[i].m_fracObj);
}
}
}
}
}
sFracturePairs.clear();
}