| Bullet Collision Detection & Physics Library
    | 
 
 
 
Go to the documentation of this file.
    4 #include "../BulletFileLoader/btBulletFile.h" 
   76                                 for (
int m = 0; m < manifoldArray.
size(); m++)
 
   81                                         int matchingManifoldIndex = -1;
 
   82                                         for (
int q = 0; q < numContactManifolds; q++)
 
   86                                                         matchingManifoldIndex = q;
 
   89                                         if (matchingManifoldIndex >= 0)
 
   91                                                 existingManifold->
deSerialize(contactManifolds[matchingManifoldIndex]);
 
   99                                         manifoldArray.
clear();
 
  109         bool isFixedBase = mbd->m_baseMass == 0;
 
  110         bool canSleep = 
false;
 
  115         baseWorldPos.
deSerialize(mbd->m_baseWorldPosition);
 
  118         baseWorldRot.
deSerialize(mbd->m_baseWorldOrientation);
 
  123         baseAngVel.
deSerialize(mbd->m_baseAngularVelocity);
 
  127         for (
int i = 0; i < mbd->m_numLinks; i++)
 
  134                 switch (mbd->m_links[i].m_jointType)
 
  177         bool isFixedBase = mbd->m_baseMass == 0;
 
  178         bool canSleep = 
false;
 
  185         baseWorldPos.
deSerialize(mbd->m_baseWorldPosition);
 
  188         baseWorldOrn.
deSerialize(mbd->m_baseWorldOrientation);
 
  193         for (
int i = 0; i < mbd->m_numLinks; i++)
 
  196                 localInertiaDiagonal.
deSerialize(mbd->m_links[i].m_linkInertia);
 
  198                 parentRotToThis.
deSerialize(mbd->m_links[i].m_zeroRotParentToThis);
 
  200                 parentComToThisPivotOffset.
deSerialize(mbd->m_links[i].m_parentComToThisPivotOffset);
 
  202                 thisPivotToThisComOffset.
deSerialize(mbd->m_links[i].m_thisPivotToThisComOffset);
 
  204                 switch (mbd->m_links[i].m_jointType)
 
  208                                 mb->
setupFixed(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
 
  209                                                            parentRotToThis, parentComToThisPivotOffset, thisPivotToThisComOffset);
 
  217                                 jointAxis.
deSerialize(mbd->m_links[i].m_jointAxisBottom[0]);
 
  218                                 bool disableParentCollision = 
true;  
 
  219                                 mb->
setupPrismatic(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
 
  220                                                                    parentRotToThis, jointAxis, parentComToThisPivotOffset, thisPivotToThisComOffset, disableParentCollision);
 
  229                                 jointAxis.
deSerialize(mbd->m_links[i].m_jointAxisTop[0]);
 
  230                                 bool disableParentCollision = 
true;  
 
  231                                 mb->
setupRevolute(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
 
  232                                                                   parentRotToThis, jointAxis, parentComToThisPivotOffset, thisPivotToThisComOffset, disableParentCollision);
 
  241                                 bool disableParentCollision = 
true;  
 
  242                                 mb->
setupSpherical(i, mbd->m_links[i].m_linkMass, localInertiaDiagonal, mbd->m_links[i].m_parentIndex,
 
  243                                                                    parentRotToThis, parentComToThisPivotOffset, thisPivotToThisComOffset, disableParentCollision);
 
  293                                         printf(
"btMultiBodyWorldImporter::convertAllObjects error: mismatch in number of links in a body (expected %d, found %d).\n", mbd->
m_numLinks, mb->getNumLinks() );
 
  331                                                 printf(
"btMultiBodyWorldImporter::convertAllObjects error: cannot find btRigidBody with bodyUniqueId %d\n", uid);
 
  337                                         printf(
"Error in btMultiBodyWorldImporter::convertAllObjects: didn't find bodyUniqueId: %d\n", uid);
 
  378                                         printf(
"btMultiBodyWorldImporter::convertAllObjects error: mismatch in number of links in a body (expected %d, found %d).\n", mbd->
m_numLinks, mb->getNumLinks() );
 
  416                                                 printf(
"btMultiBodyWorldImporter::convertAllObjects error: cannot find btRigidBody with bodyUniqueId %d\n", uid);
 
  422                                         printf(
"Error in btMultiBodyWorldImporter::convertAllObjects: didn't find bodyUniqueId: %d\n", uid);
 
  458                 for (
int i = 0; i < bulletFile2->m_multiBodies.size(); i++)
 
  473                 for (
int i = 0; i < m_data->m_mbMap.size(); i++)
 
  487                 for (
int i = 0; i < bulletFile2->m_multiBodyLinkColliders.size(); i++)
 
  499                                         if (shapePtr && *shapePtr)
 
  524                                                         int mbLinkIndex = mblcd->
m_link;
 
  526                                                         bool isDynamic = (mbLinkIndex < 0 && multiBody->
hasFixedBase()) ? 
false : 
true;
 
  531                                                         int colGroup = 0, colMask = 0;
 
  533                                                         if (collisionFlags & URDF_HAS_COLLISION_GROUP)
 
  535                                                                 collisionFilterGroup = colGroup;
 
  537                                                         if (collisionFlags & URDF_HAS_COLLISION_MASK)
 
  539                                                                 collisionFilterMask = colMask;
 
  542                                                         m_data->m_mbDynamicsWorld->addCollisionObject(col, collisionFilterGroup, collisionFilterMask);
 
  547                                                 printf(
"error: no shape found\n");
 
  552                                         world1->addCollisionObject(col, collisionFilterGroup, collisionFilterMask);
 
  558                 for (
int i = 0; i < m_data->m_mbMap.size(); i++)
 
  566                                 m_data->m_mbDynamicsWorld->addMultiBody(mb);
 
  
void setupFixed(int linkIndex, btScalar mass, const btVector3 &inertia, int parent, const btQuaternion &rotParentToThis, const btVector3 &parentComToThisPivotOffset, const btVector3 &thisPivotToThisComOffset, bool deprecatedDisableParentCollision=true)
const btVector3 getBaseVel() const
virtual void computeOverlappingPairs()
the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSi...
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
The btRigidBody is the main class for rigid body objects.
void setupSpherical(int linkIndex, btScalar mass, const btVector3 &inertia, int parent, const btQuaternion &rotParentToThis, const btVector3 &parentComToThisPivotOffset, const btVector3 &thisPivotToThisComOffset, bool disableParentCollision=false)
btCollisionObjectDoubleData * m_body1
struct btMultiBodyWorldImporterInternalData * m_data
virtual btBroadphasePairArray & getOverlappingPairArray()=0
void setJointPosMultiDof(int i, const double *q)
The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatr...
void setNumContacts(int cachedPoints)
the setNumContacts API is usually not used, except when you gather/fill all contacts manually
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void convertMultiBody(T *mbd, btMultiBodyWorldImporterInternalData *m_data)
The btDispatcher interface class can be used in combination with broadphase to dispatch calculations ...
void setWorldToBaseRot(const btQuaternion &rot)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btQuaternion inverse() const
Return the inverse of this quaternion.
btAlignedObjectArray< bStructHandle * > m_multiBodies
void setJointVelMultiDof(int i, const double *qdot)
virtual bool convertAllObjects(bParse::btBulletFile *bulletFile2)
void deSerialize(const struct btPersistentManifoldDoubleData *manifoldDataPtr)
btHashMap< btHashPtr, btMultiBody * > m_mbMap
const btCollisionObject * getBody0() const
void setupRevolute(int linkIndex, btScalar mass, const btVector3 &inertia, int parentIndex, const btQuaternion &rotParentToThis, const btVector3 &jointAxis, const btVector3 &parentComToThisPivotOffset, const btVector3 &thisPivotToThisComOffset, bool disableParentCollision=false)
btSpatialMotionVector m_absFrameTotVelocity
virtual int getNumManifolds() const =0
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
static btCollisionObjectDoubleData * getBody0FromContactManifold(btPersistentManifoldDoubleData *manifold)
virtual int getNumOverlappingPairs() const =0
btCollisionObjectDoubleData m_collisionObjectData
btCollisionObjectFloatData * m_body0
void updateCollisionObjectWorldTransforms(btAlignedObjectArray< btQuaternion > &scratch_q, btAlignedObjectArray< btVector3 > &scratch_m)
btTransformDoubleData m_worldTransform
btAlignedObjectArray< bStructHandle * > m_rigidBodies
const btBroadphaseInterface * getBroadphase() const
btTransform getBaseWorldTransform() const
static btCollisionObjectDoubleData * getBody1FromContactManifold(btPersistentManifoldDoubleData *manifold)
void setBaseVel(const btVector3 &vel)
btTransform m_cachedWorldTransform
virtual void deleteAllData()
delete all memory collision shapes, rigid bodies, constraints etc.
void setupPrismatic(int i, btScalar mass, const btVector3 &inertia, int parent, const btQuaternion &rotParentToThis, const btVector3 &jointAxis, const btVector3 &parentComToThisPivotOffset, const btVector3 &thisPivotToThisComOffset, bool disableParentCollision)
void setLinearVelocity(const btVector3 &lin_vel)
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
void setRestitution(btScalar rest)
btAlignedObjectArray< bStructHandle * > m_contactManifolds
void setBaseCollider(btMultiBodyLinkCollider *collider)
virtual void setCollisionShape(btCollisionShape *collisionShape)
btTransformFloatData m_worldTransform
btVector3 getBaseOmega() const
btCollisionObjectFloatData * m_body1
btMultiBodyDynamicsWorld * m_mbDynamicsWorld
bool hasFixedBase() const
btMultiBodyDoubleData * m_multiBody
The btOverlappingPairCache provides an interface for overlapping pair management (add,...
btBroadphaseProxy * getBroadphaseHandle()
void setFriction(btScalar frict)
void setJointPos(int i, btScalar q)
void setWorldTransform(const btTransform &worldTrans)
int getNumCollisionObjects() const
void setBaseOmega(const btVector3 &omega)
btCollisionAlgorithm * m_algorithm
void * findLibPointer(void *ptr)
btCollisionObjectFloatData m_collisionObjectData
void forwardKinematics(btAlignedObjectArray< btQuaternion > &scratch_q, btAlignedObjectArray< btVector3 > &scratch_m)
const btMultibodyLink & getLink(int index) const
btVector3 can be used to represent 3D points and vectors.
void setHasSelfCollision(bool hasSelfCollision)
btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping...
void setJointVel(int i, btScalar qdot)
virtual void deleteAllData()
delete all memory collision shapes, rigid bodies, constraints etc.
btCollisionObjectDoubleData * m_body0
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btMultiBody * getMultiBody(int mbIndex)
btMultiBodyWorldImporter(class btMultiBodyDynamicsWorld *world)
class btMultiBodyLinkCollider * m_collider
btCollisionObjectDoubleData m_colObjData
void setAngularVelocity(const btVector3 &ang_vel)
The btBulletWorldImporter is a starting point to import .bullet files.
btSpatialMotionVector m_absFrameLocVelocity
btVector3DoubleData m_linearVelocity
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
virtual void dispatchAllCollisionPairs(btOverlappingPairCache *pairCache, const btDispatcherInfo &dispatchInfo, btDispatcher *dispatcher)=0
void insert(const Key &key, const Value &value)
virtual void updateAabbs()
void deSerializeDouble(const struct btVector3DoubleData &dataIn)
btVector3FloatData m_angularVelocity
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_linearVelocity
virtual int getNumMultibodies() const
void deSerialize(const struct btQuaternionFloatData &dataIn)
void deSerialize(const struct btVector3DoubleData &dataIn)
virtual void getAllContactManifolds(btManifoldArray &manifoldArray)=0
btDispatcher * getDispatcher()
void deSerializeFloat(const struct btVector3FloatData &dataIn)
virtual btOverlappingPairCache * getOverlappingPairCache()=0
virtual bool convertAllObjects(bParse::btBulletFile *file)
const btCollisionObject * getBody1() const
btCollisionObjectArray & getCollisionObjectArray()
The btMultiBodyDynamicsWorld adds Featherstone multi body dynamics to Bullet This implementation is s...
void syncMultiBody(T *mbd, btMultiBody *mb, btMultiBodyWorldImporterInternalData *m_data, btAlignedObjectArray< btQuaternion > &scratchQ, btAlignedObjectArray< btVector3 > &scratchM)
btDispatcherInfo & getDispatchInfo()
void setBasePos(const btVector3 &pos)
The btBroadphasePair class contains a pair of aabb-overlapping objects.
static const btRigidBody * upcast(const btCollisionObject *colObj)
to keep collision detection and dynamics separate we don't store a rigidbody pointer but a rigidbody ...
virtual ~btMultiBodyWorldImporter()
int size() const
return the number of elements in the array
btVector3DoubleData m_angularVelocity
void syncContactManifolds(T **contactManifolds, int numContactManifolds, btMultiBodyWorldImporterInternalData *m_data)