Bullet Collision Detection & Physics Library
btCollisionObject.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 #ifndef BT_COLLISION_OBJECT_H
17 #define BT_COLLISION_OBJECT_H
18 
19 #include "LinearMath/btTransform.h"
20 
21 //island management, m_activationState1
22 #define ACTIVE_TAG 1
23 #define ISLAND_SLEEPING 2
24 #define WANTS_DEACTIVATION 3
25 #define DISABLE_DEACTIVATION 4
26 #define DISABLE_SIMULATION 5
27 
28 struct btBroadphaseProxy;
29 class btCollisionShape;
34 
36 
37 #ifdef BT_USE_DOUBLE_PRECISION
38 #define btCollisionObjectData btCollisionObjectDoubleData
39 #define btCollisionObjectDataName "btCollisionObjectDoubleData"
40 #else
41 #define btCollisionObjectData btCollisionObjectFloatData
42 #define btCollisionObjectDataName "btCollisionObjectFloatData"
43 #endif
44 
45 
50 {
51 
52 protected:
53 
55 
59  //those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities)
60  //without destroying the continuous interpolated motion (which uses this interpolation velocities)
63 
67 
72 
77 
79 
82  int m_worldArrayIndex; // index of object in world's collisionObjects array
83 
84  mutable int m_activationState1;
86 
89  btScalar m_rollingFriction;//torsional friction orthogonal to contact normal (useful to stop spheres rolling forever)
90  btScalar m_spinningFriction; // torsional friction around the contact normal (useful for grasping)
93 
94 
95 
99 
101 
103 
105 
107 
110 
113 
116 
119 
121 
124 
126 
127 public:
128 
130 
132  {
133  CF_STATIC_OBJECT= 1,
134  CF_KINEMATIC_OBJECT= 2,
135  CF_NO_CONTACT_RESPONSE = 4,
136  CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
137  CF_CHARACTER_OBJECT = 16,
138  CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing
139  CF_DISABLE_SPU_COLLISION_PROCESSING = 64,//disable parallel/SPU processing
140  CF_HAS_CONTACT_STIFFNESS_DAMPING = 128,
141  CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256,
142  };
143 
145  {
146  CO_COLLISION_OBJECT =1,
147  CO_RIGID_BODY=2,
150  CO_GHOST_OBJECT=4,
151  CO_SOFT_BODY=8,
152  CO_HF_FLUID=16,
153  CO_USER_TYPE=32,
154  CO_FEATHERSTONE_LINK=64
155  };
156 
158  {
159  CF_ANISOTROPIC_FRICTION_DISABLED=0,
160  CF_ANISOTROPIC_FRICTION = 1,
161  CF_ANISOTROPIC_ROLLING_FRICTION = 2
162  };
163 
165  {
167  return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE) )==0);
168  }
169 
171  {
172  return m_anisotropicFriction;
173  }
174  void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
175  {
176  m_anisotropicFriction = anisotropicFriction;
177  bool isUnity = (anisotropicFriction[0]!=1.f) || (anisotropicFriction[1]!=1.f) || (anisotropicFriction[2]!=1.f);
178  m_hasAnisotropicFriction = isUnity?frictionMode : 0;
179  }
180  bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const
181  {
182  return (m_hasAnisotropicFriction&frictionMode)!=0;
183  }
184 
187  void setContactProcessingThreshold( btScalar contactProcessingThreshold)
188  {
189  m_contactProcessingThreshold = contactProcessingThreshold;
190  }
192  {
193  return m_contactProcessingThreshold;
194  }
195 
197  return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
198  }
199 
201  {
202  return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
203  }
204 
206  {
207  return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0 ;
208  }
209 
211  return (m_collisionFlags & CF_NO_CONTACT_RESPONSE)==0;
212  }
213 
214 
216 
217  virtual ~btCollisionObject();
218 
219  virtual void setCollisionShape(btCollisionShape* collisionShape)
220  {
221  m_updateRevision++;
222  m_collisionShape = collisionShape;
223  m_rootCollisionShape = collisionShape;
224  }
225 
227  {
228  return m_collisionShape;
229  }
230 
232  {
233  return m_collisionShape;
234  }
235 
236  void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck)
237  {
238  if (ignoreCollisionCheck)
239  {
240  //We don't check for duplicates. Is it ok to leave that up to the user of this API?
241  //int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
242  //if (index == m_objectsWithoutCollisionCheck.size())
243  //{
244  m_objectsWithoutCollisionCheck.push_back(co);
245  //}
246  }
247  else
248  {
249  m_objectsWithoutCollisionCheck.remove(co);
250  }
251  m_checkCollideWith = m_objectsWithoutCollisionCheck.size() > 0;
252  }
253 
254  virtual bool checkCollideWithOverride(const btCollisionObject* co) const
255  {
256  int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
257  if (index < m_objectsWithoutCollisionCheck.size())
258  {
259  return false;
260  }
261  return true;
262  }
263 
264 
265 
266 
270  {
271  return m_extensionPointer;
272  }
275  void internalSetExtensionPointer(void* pointer)
276  {
277  m_extensionPointer = pointer;
278  }
279 
280  SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1;}
281 
282  void setActivationState(int newState) const;
283 
285  {
286  m_deactivationTime = time;
287  }
289  {
290  return m_deactivationTime;
291  }
292 
293  void forceActivationState(int newState) const;
294 
295  void activate(bool forceActivation = false) const;
296 
298  {
299  return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
300  }
301 
303  {
304  m_updateRevision++;
305  m_restitution = rest;
306  }
308  {
309  return m_restitution;
310  }
311  void setFriction(btScalar frict)
312  {
313  m_updateRevision++;
314  m_friction = frict;
315  }
317  {
318  return m_friction;
319  }
320 
322  {
323  m_updateRevision++;
324  m_rollingFriction = frict;
325  }
327  {
328  return m_rollingFriction;
329  }
331  {
332  m_updateRevision++;
333  m_spinningFriction = frict;
334  }
336  {
337  return m_spinningFriction;
338  }
340  {
341  m_updateRevision++;
342  m_contactStiffness = stiffness;
343  m_contactDamping = damping;
344 
345  m_collisionFlags |=CF_HAS_CONTACT_STIFFNESS_DAMPING;
346 
347  //avoid divisions by zero...
348  if (m_contactStiffness< SIMD_EPSILON)
349  {
350  m_contactStiffness = SIMD_EPSILON;
351  }
352  }
353 
355  {
356  return m_contactStiffness;
357  }
358 
360  {
361  return m_contactDamping;
362  }
363 
365  int getInternalType() const
366  {
367  return m_internalType;
368  }
369 
371  {
372  return m_worldTransform;
373  }
374 
376  {
377  return m_worldTransform;
378  }
379 
380  void setWorldTransform(const btTransform& worldTrans)
381  {
382  m_updateRevision++;
383  m_worldTransform = worldTrans;
384  }
385 
386 
388  {
389  return m_broadphaseHandle;
390  }
391 
393  {
394  return m_broadphaseHandle;
395  }
396 
398  {
399  m_broadphaseHandle = handle;
400  }
401 
402 
404  {
405  return m_interpolationWorldTransform;
406  }
407 
409  {
410  return m_interpolationWorldTransform;
411  }
412 
414  {
415  m_updateRevision++;
416  m_interpolationWorldTransform = trans;
417  }
418 
420  {
421  m_updateRevision++;
422  m_interpolationLinearVelocity = linvel;
423  }
424 
426  {
427  m_updateRevision++;
428  m_interpolationAngularVelocity = angvel;
429  }
430 
432  {
433  return m_interpolationLinearVelocity;
434  }
435 
437  {
438  return m_interpolationAngularVelocity;
439  }
440 
442  {
443  return m_islandTag1;
444  }
445 
446  void setIslandTag(int tag)
447  {
448  m_islandTag1 = tag;
449  }
450 
452  {
453  return m_companionId;
454  }
455 
456  void setCompanionId(int id)
457  {
458  m_companionId = id;
459  }
460 
462  {
463  return m_worldArrayIndex;
464  }
465 
466  // only should be called by CollisionWorld
467  void setWorldArrayIndex(int ix)
468  {
469  m_worldArrayIndex = ix;
470  }
471 
473  {
474  return m_hitFraction;
475  }
476 
477  void setHitFraction(btScalar hitFraction)
478  {
479  m_hitFraction = hitFraction;
480  }
481 
482 
484  {
485  return m_collisionFlags;
486  }
487 
488  void setCollisionFlags(int flags)
489  {
490  m_collisionFlags = flags;
491  }
492 
495  {
496  return m_ccdSweptSphereRadius;
497  }
498 
501  {
502  m_ccdSweptSphereRadius = radius;
503  }
504 
506  {
507  return m_ccdMotionThreshold;
508  }
509 
511  {
512  return m_ccdMotionThreshold*m_ccdMotionThreshold;
513  }
514 
515 
516 
518  void setCcdMotionThreshold(btScalar ccdMotionThreshold)
519  {
520  m_ccdMotionThreshold = ccdMotionThreshold;
521  }
522 
524  void* getUserPointer() const
525  {
526  return m_userObjectPointer;
527  }
528 
529  int getUserIndex() const
530  {
531  return m_userIndex;
532  }
533 
534  int getUserIndex2() const
535  {
536  return m_userIndex2;
537  }
538 
540  void setUserPointer(void* userPointer)
541  {
542  m_userObjectPointer = userPointer;
543  }
544 
546  void setUserIndex(int index)
547  {
548  m_userIndex = index;
549  }
550 
551  void setUserIndex2(int index)
552  {
553  m_userIndex2 = index;
554  }
555 
557  {
558  return m_updateRevision;
559  }
560 
561  void setCustomDebugColor(const btVector3& colorRGB)
562  {
563  m_customDebugColorRGB = colorRGB;
564  m_collisionFlags |= CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
565  }
566 
568  {
569  m_collisionFlags &= ~CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
570  }
571 
572  bool getCustomDebugColor(btVector3& colorRGB) const
573  {
574  bool hasCustomColor = (0!=(m_collisionFlags&CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR));
575  if (hasCustomColor)
576  {
577  colorRGB = m_customDebugColorRGB;
578  }
579  return hasCustomColor;
580  }
581 
582  inline bool checkCollideWith(const btCollisionObject* co) const
583  {
584  if (m_checkCollideWith)
585  return checkCollideWithOverride(co);
586 
587  return true;
588  }
589 
590  virtual int calculateSerializeBufferSize() const;
591 
593  virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
594 
595  virtual void serializeSingleObject(class btSerializer* serializer) const;
596 
597 };
598 
601 {
605  char *m_name;
606 
614  double m_friction;
619  double m_hitFraction;
622 
630 
631  char m_padding[4];
632 };
633 
636 {
640  char *m_name;
641 
649  float m_friction;
657 
665  char m_padding[4];
666 };
667 
668 
669 
671 {
672  return sizeof(btCollisionObjectData);
673 }
674 
675 
676 
677 #endif //BT_COLLISION_OBJECT_H
btTransformFloatData m_worldTransform
void setUserIndex2(int index)
#define SIMD_EPSILON
Definition: btScalar.h:495
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
const btVector3 & getInterpolationAngularVelocity() const
void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
void push_back(const T &_Val)
int getUserIndex2() const
btVector3FloatData m_anisotropicFriction
btScalar getContactDamping() const
bool mergesSimulationIslands() const
btScalar m_ccdMotionThreshold
Don&#39;t do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
int findLinearSearch(const T &key) const
const btBroadphaseProxy * getBroadphaseHandle() const
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
btScalar m_ccdSweptSphereRadius
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
btTransformFloatData m_interpolationWorldTransform
void setCcdMotionThreshold(btScalar ccdMotionThreshold)
Don&#39;t do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
btScalar getContactStiffness() const
btAlignedObjectArray< const btCollisionObject * > m_objectsWithoutCollisionCheck
btScalar m_hitFraction
time of impact calculation
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
void setHitFraction(btScalar hitFraction)
bool isKinematicObject() const
const btTransform & getWorldTransform() const
void setWorldArrayIndex(int ix)
#define SIMD_FORCE_INLINE
Definition: btScalar.h:64
int getActivationState() const
#define btCollisionObjectData
btTransform m_worldTransform
#define ISLAND_SLEEPING
bool isStaticOrKinematicObject() const
void setCustomDebugColor(const btVector3 &colorRGB)
btVector3DoubleData m_anisotropicFriction
btCollisionShape * m_collisionShape
btCollisionShapeData * m_rootCollisionShape
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
void setRestitution(btScalar rest)
bool checkCollideWith(const btCollisionObject *co) const
btVector3DoubleData m_interpolationAngularVelocity
btCollisionShapeData * m_rootCollisionShape
const btVector3 & getInterpolationLinearVelocity() const
btVector3 m_anisotropicFriction
virtual void setCollisionShape(btCollisionShape *collisionShape)
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
btTransform & getWorldTransform()
int m_internalType
m_internalType is reserved to distinguish Bullet&#39;s btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
btBroadphaseProxy * getBroadphaseHandle()
const btVector3 & getAnisotropicFriction() const
void setFriction(btScalar frict)
btScalar getCcdSquareMotionThreshold() const
bool isStaticObject() const
void setCcdSweptSphereRadius(btScalar radius)
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
btCollisionShape * m_rootCollisionShape
m_rootCollisionShape is temporarily used to store the original collision shape The m_collisionShape m...
void setSpinningFriction(btScalar frict)
btVector3FloatData m_interpolationLinearVelocity
btAlignedObjectArray< class btCollisionObject * > btCollisionObjectArray
btScalar getRestitution() const
btTransform & getInterpolationWorldTransform()
btScalar getDeactivationTime() const
btCollisionObject can be used to manage collision detection objects.
void setUserPointer(void *userPointer)
users can point to their objects, userPointer is not used by Bullet
#define DISABLE_SIMULATION
bool hasContactResponse() const
const btTransform & getInterpolationWorldTransform() const
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
void * m_extensionPointer
m_extensionPointer is used by some internal low-level Bullet extensions.
btVector3 m_customDebugColorRGB
btScalar m_contactProcessingThreshold
virtual int calculateSerializeBufferSize() const
void setDeactivationTime(btScalar time)
void setWorldTransform(const btTransform &worldTrans)
void setCompanionId(int id)
int getWorldArrayIndex() const
int m_updateRevision
internal update revision number. It will be increased when the object changes. This allows some subsy...
btScalar getRollingFriction() const
int getUserIndex() const
void setInterpolationWorldTransform(const btTransform &trans)
int getCollisionFlags() const
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
btScalar getContactProcessingThreshold() const
void * internalGetExtensionPointer() const
Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
void setInterpolationAngularVelocity(const btVector3 &angvel)
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:65
int size() const
return the number of elements in the array
void setAnisotropicFriction(const btVector3 &anisotropicFriction, int frictionMode=CF_ANISOTROPIC_FRICTION)
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btScalar getCcdMotionThreshold() const
btCollisionShape * getCollisionShape()
int getIslandTag() const
void setCollisionFlags(int flags)
void setBroadphaseHandle(btBroadphaseProxy *handle)
btScalar getSpinningFriction() const
btScalar getHitFraction() const
void remove(const T &key)
btTransformDoubleData m_worldTransform
btTransformDoubleData m_interpolationWorldTransform
btVector3 m_interpolationAngularVelocity
for serialization
Definition: btTransform.h:253
void setIslandTag(int tag)
int getInternalType() const
reserved for Bullet internal usage
void setRollingFriction(btScalar frict)
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:389
btVector3DoubleData m_interpolationLinearVelocity
int m_checkCollideWith
If some object should have elaborate collision filtering by sub-classes.
void internalSetExtensionPointer(void *pointer)
Avoid using this internal API call, the extension pointer is used by some Bullet extensions If you ne...
bool getCustomDebugColor(btVector3 &colorRGB) const
void * m_userObjectPointer
users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPoin...
void setInterpolationLinearVelocity(const btVector3 &linvel)
bool hasAnisotropicFriction(int frictionMode=CF_ANISOTROPIC_FRICTION) const
btBroadphaseProxy * m_broadphaseHandle
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
btVector3 m_interpolationLinearVelocity
void setContactProcessingThreshold(btScalar contactProcessingThreshold)
the constraint solver can discard solving contacts, if the distance is above this threshold...
btScalar getFriction() const
btVector3FloatData m_interpolationAngularVelocity
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
int getCompanionId() const
virtual bool checkCollideWithOverride(const btCollisionObject *co) const
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:279
const btCollisionShape * getCollisionShape() const
void * getUserPointer() const
users can point to their objects, userPointer is not used by Bullet
int getUpdateRevisionInternal() const