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 
50 {
51 protected:
53 
57  //those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities)
58  //without destroying the continuous interpolated motion (which uses this interpolation velocities)
61 
65 
70 
75 
77 
80  int m_worldArrayIndex; // index of object in world's collisionObjects array
81 
82  mutable int m_activationState1;
84 
87  btScalar m_rollingFriction; //torsional friction orthogonal to contact normal (useful to stop spheres rolling forever)
88  btScalar m_spinningFriction; // torsional friction around the contact normal (useful for grasping)
91 
95 
97 
99 
101 
103 
105 
108 
111 
114 
117 
119 
122 
124 
125 public:
127 
129  {
130  CF_STATIC_OBJECT = 1,
131  CF_KINEMATIC_OBJECT = 2,
132  CF_NO_CONTACT_RESPONSE = 4,
133  CF_CUSTOM_MATERIAL_CALLBACK = 8, //this allows per-triangle material (friction/restitution)
134  CF_CHARACTER_OBJECT = 16,
135  CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing
136  CF_DISABLE_SPU_COLLISION_PROCESSING = 64, //disable parallel/SPU processing
137  CF_HAS_CONTACT_STIFFNESS_DAMPING = 128,
138  CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256,
139  CF_HAS_FRICTION_ANCHOR = 512,
140  CF_HAS_COLLISION_SOUND_TRIGGER = 1024
141  };
142 
144  {
145  CO_COLLISION_OBJECT = 1,
146  CO_RIGID_BODY = 2,
149  CO_GHOST_OBJECT = 4,
150  CO_SOFT_BODY = 8,
151  CO_HF_FLUID = 16,
152  CO_USER_TYPE = 32,
153  CO_FEATHERSTONE_LINK = 64
154  };
155 
157  {
158  CF_ANISOTROPIC_FRICTION_DISABLED = 0,
159  CF_ANISOTROPIC_FRICTION = 1,
160  CF_ANISOTROPIC_ROLLING_FRICTION = 2
161  };
162 
164  {
166  return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE)) == 0);
167  }
168 
170  {
171  return m_anisotropicFriction;
172  }
173  void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
174  {
175  m_anisotropicFriction = anisotropicFriction;
176  bool isUnity = (anisotropicFriction[0] != 1.f) || (anisotropicFriction[1] != 1.f) || (anisotropicFriction[2] != 1.f);
177  m_hasAnisotropicFriction = isUnity ? frictionMode : 0;
178  }
179  bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const
180  {
181  return (m_hasAnisotropicFriction & frictionMode) != 0;
182  }
183 
186  void setContactProcessingThreshold(btScalar contactProcessingThreshold)
187  {
188  m_contactProcessingThreshold = contactProcessingThreshold;
189  }
191  {
192  return m_contactProcessingThreshold;
193  }
194 
196  {
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  {
212  return (m_collisionFlags & CF_NO_CONTACT_RESPONSE) == 0;
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 
255  {
256  return m_objectsWithoutCollisionCheck.size();
257  }
258 
260  {
261  return m_objectsWithoutCollisionCheck[index];
262  }
263 
264  virtual bool checkCollideWithOverride(const btCollisionObject* co) const
265  {
266  int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
267  if (index < m_objectsWithoutCollisionCheck.size())
268  {
269  return false;
270  }
271  return true;
272  }
273 
277  {
278  return m_extensionPointer;
279  }
282  void internalSetExtensionPointer(void* pointer)
283  {
284  m_extensionPointer = pointer;
285  }
286 
287  SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1; }
288 
289  void setActivationState(int newState) const;
290 
292  {
293  m_deactivationTime = time;
294  }
296  {
297  return m_deactivationTime;
298  }
299 
300  void forceActivationState(int newState) const;
301 
302  void activate(bool forceActivation = false) const;
303 
305  {
306  return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
307  }
308 
310  {
311  m_updateRevision++;
312  m_restitution = rest;
313  }
315  {
316  return m_restitution;
317  }
318  void setFriction(btScalar frict)
319  {
320  m_updateRevision++;
321  m_friction = frict;
322  }
324  {
325  return m_friction;
326  }
327 
329  {
330  m_updateRevision++;
331  m_rollingFriction = frict;
332  }
334  {
335  return m_rollingFriction;
336  }
338  {
339  m_updateRevision++;
340  m_spinningFriction = frict;
341  }
343  {
344  return m_spinningFriction;
345  }
347  {
348  m_updateRevision++;
349  m_contactStiffness = stiffness;
350  m_contactDamping = damping;
351 
352  m_collisionFlags |= CF_HAS_CONTACT_STIFFNESS_DAMPING;
353 
354  //avoid divisions by zero...
355  if (m_contactStiffness < SIMD_EPSILON)
356  {
357  m_contactStiffness = SIMD_EPSILON;
358  }
359  }
360 
362  {
363  return m_contactStiffness;
364  }
365 
367  {
368  return m_contactDamping;
369  }
370 
372  int getInternalType() const
373  {
374  return m_internalType;
375  }
376 
378  {
379  return m_worldTransform;
380  }
381 
383  {
384  return m_worldTransform;
385  }
386 
387  void setWorldTransform(const btTransform& worldTrans)
388  {
389  m_updateRevision++;
390  m_worldTransform = worldTrans;
391  }
392 
394  {
395  return m_broadphaseHandle;
396  }
397 
399  {
400  return m_broadphaseHandle;
401  }
402 
404  {
405  m_broadphaseHandle = handle;
406  }
407 
409  {
410  return m_interpolationWorldTransform;
411  }
412 
414  {
415  return m_interpolationWorldTransform;
416  }
417 
419  {
420  m_updateRevision++;
421  m_interpolationWorldTransform = trans;
422  }
423 
425  {
426  m_updateRevision++;
427  m_interpolationLinearVelocity = linvel;
428  }
429 
431  {
432  m_updateRevision++;
433  m_interpolationAngularVelocity = angvel;
434  }
435 
437  {
438  return m_interpolationLinearVelocity;
439  }
440 
442  {
443  return m_interpolationAngularVelocity;
444  }
445 
447  {
448  return m_islandTag1;
449  }
450 
451  void setIslandTag(int tag)
452  {
453  m_islandTag1 = tag;
454  }
455 
457  {
458  return m_companionId;
459  }
460 
461  void setCompanionId(int id)
462  {
463  m_companionId = id;
464  }
465 
467  {
468  return m_worldArrayIndex;
469  }
470 
471  // only should be called by CollisionWorld
472  void setWorldArrayIndex(int ix)
473  {
474  m_worldArrayIndex = ix;
475  }
476 
478  {
479  return m_hitFraction;
480  }
481 
482  void setHitFraction(btScalar hitFraction)
483  {
484  m_hitFraction = hitFraction;
485  }
486 
488  {
489  return m_collisionFlags;
490  }
491 
492  void setCollisionFlags(int flags)
493  {
494  m_collisionFlags = flags;
495  }
496 
499  {
500  return m_ccdSweptSphereRadius;
501  }
502 
505  {
506  m_ccdSweptSphereRadius = radius;
507  }
508 
510  {
511  return m_ccdMotionThreshold;
512  }
513 
515  {
516  return m_ccdMotionThreshold * m_ccdMotionThreshold;
517  }
518 
520  void setCcdMotionThreshold(btScalar ccdMotionThreshold)
521  {
522  m_ccdMotionThreshold = ccdMotionThreshold;
523  }
524 
526  void* getUserPointer() const
527  {
528  return m_userObjectPointer;
529  }
530 
531  int getUserIndex() const
532  {
533  return m_userIndex;
534  }
535 
536  int getUserIndex2() const
537  {
538  return m_userIndex2;
539  }
540 
541  int getUserIndex3() const
542  {
543  return m_userIndex3;
544  }
545 
547  void setUserPointer(void* userPointer)
548  {
549  m_userObjectPointer = userPointer;
550  }
551 
553  void setUserIndex(int index)
554  {
555  m_userIndex = index;
556  }
557 
558  void setUserIndex2(int index)
559  {
560  m_userIndex2 = index;
561  }
562 
563  void setUserIndex3(int index)
564  {
565  m_userIndex3 = index;
566  }
567 
569  {
570  return m_updateRevision;
571  }
572 
573  void setCustomDebugColor(const btVector3& colorRGB)
574  {
575  m_customDebugColorRGB = colorRGB;
576  m_collisionFlags |= CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
577  }
578 
580  {
581  m_collisionFlags &= ~CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
582  }
583 
584  bool getCustomDebugColor(btVector3 & colorRGB) const
585  {
586  bool hasCustomColor = (0 != (m_collisionFlags & CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR));
587  if (hasCustomColor)
588  {
589  colorRGB = m_customDebugColorRGB;
590  }
591  return hasCustomColor;
592  }
593 
594  inline bool checkCollideWith(const btCollisionObject* co) const
595  {
596  if (m_checkCollideWith)
597  return checkCollideWithOverride(co);
598 
599  return true;
600  }
601 
602  virtual int calculateSerializeBufferSize() const;
603 
605  virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
606 
607  virtual void serializeSingleObject(class btSerializer * serializer) const;
608 };
609 
610 // clang-format off
611 
614 {
618  char *m_name;
619 
627  double m_friction;
632  double m_hitFraction;
644  int m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
645 };
646 
649 {
653  char *m_name;
654 
662  float m_friction;
680 };
681 // clang-format on
682 
684 {
685  return sizeof(btCollisionObjectData);
686 }
687 
688 #endif //BT_COLLISION_OBJECT_H
SIMD_EPSILON
#define SIMD_EPSILON
Definition: btScalar.h:543
btCollisionShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCollisionShape.h:163
btCollisionObject::checkCollideWithOverride
virtual bool checkCollideWithOverride(const btCollisionObject *co) const
Definition: btCollisionObject.h:264
btTransformDoubleData
Definition: btTransform.h:251
btCollisionObject::m_userIndex
int m_userIndex
Definition: btCollisionObject.h:102
btCollisionObject
btCollisionObject can be used to manage collision detection objects.
Definition: btCollisionObject.h:50
DISABLE_SIMULATION
#define DISABLE_SIMULATION
Definition: btCollisionObject.h:26
btCollisionObjectDoubleData::m_collisionFilterMask
int m_collisionFilterMask
Definition: btCollisionObject.h:643
btCollisionObject::getContactDamping
btScalar getContactDamping() const
Definition: btCollisionObject.h:366
btBroadphaseProxy
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
Definition: btBroadphaseProxy.h:86
btCollisionObject::getUserIndex2
int getUserIndex2() const
Definition: btCollisionObject.h:536
btCollisionObjectDoubleData::m_ccdMotionThreshold
double m_ccdMotionThreshold
Definition: btCollisionObject.h:634
btCollisionObject::getUpdateRevisionInternal
int getUpdateRevisionInternal() const
Definition: btCollisionObject.h:568
btCollisionObjectFloatData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:671
btCollisionObject::m_ccdSweptSphereRadius
btScalar m_ccdSweptSphereRadius
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:110
btCollisionObjectFloatData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:676
btCollisionObject::m_interpolationWorldTransform
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
Definition: btCollisionObject.h:56
btCollisionObjectDoubleData::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:637
btCollisionObject::AnisotropicFrictionFlags
AnisotropicFrictionFlags
Definition: btCollisionObject.h:157
btCollisionObject::setContactStiffnessAndDamping
void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
Definition: btCollisionObject.h:346
btCollisionObjectDoubleData::m_uniqueId
int m_uniqueId
Definition: btCollisionObject.h:644
btCollisionObject::getBroadphaseHandle
const btBroadphaseProxy * getBroadphaseHandle() const
Definition: btCollisionObject.h:398
btCollisionObjectFloatData::m_internalType
int m_internalType
Definition: btCollisionObject.h:675
btCollisionObjectFloatData::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:672
btCollisionObjectFloatData::m_name
char * m_name
Definition: btCollisionObject.h:653
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
btMotionState.h
btCollisionObjectFloatData::m_collisionFilterGroup
int m_collisionFilterGroup
Definition: btCollisionObject.h:677
btCollisionObjectDoubleData::m_rollingFriction
double m_rollingFriction
Definition: btCollisionObject.h:628
btCollisionObjectDoubleData::m_companionId
int m_companionId
Definition: btCollisionObject.h:638
btCollisionObjectDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCollisionObject.h:614
btCollisionObject::setCcdMotionThreshold
void setCcdMotionThreshold(btScalar ccdMotionThreshold)
Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
Definition: btCollisionObject.h:520
btCollisionObject::m_objectsWithoutCollisionCheck
btAlignedObjectArray< const btCollisionObject * > m_objectsWithoutCollisionCheck
Definition: btCollisionObject.h:118
btCollisionObject::mergesSimulationIslands
bool mergesSimulationIslands() const
Definition: btCollisionObject.h:163
btCollisionObjectFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCollisionObject.h:649
btCollisionObject::setWorldArrayIndex
void setWorldArrayIndex(int ix)
Definition: btCollisionObject.h:472
btCollisionObjectDoubleData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:615
btCollisionObject::m_ccdMotionThreshold
btScalar m_ccdMotionThreshold
Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
Definition: btCollisionObject.h:113
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition: btAlignedObjectArray.h:438
btCollisionObject::removeCustomDebugColor
void removeCustomDebugColor()
Definition: btCollisionObject.h:579
btCollisionObjectFloatData::m_interpolationWorldTransform
btTransformFloatData m_interpolationWorldTransform
Definition: btCollisionObject.h:656
btCollisionObjectData
#define btCollisionObjectData
Definition: btCollisionObject.h:41
btCollisionObject::getActivationState
int getActivationState() const
Definition: btCollisionObject.h:287
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition: btCollisionObject.h:52
btCollisionObjectDoubleData::m_interpolationWorldTransform
btTransformDoubleData m_interpolationWorldTransform
Definition: btCollisionObject.h:621
btCollisionObject::setCustomDebugColor
void setCustomDebugColor(const btVector3 &colorRGB)
Definition: btCollisionObject.h:573
btCollisionObjectDoubleData::m_worldTransform
btTransformDoubleData m_worldTransform
Definition: btCollisionObject.h:620
btCollisionObject::getContactStiffness
btScalar getContactStiffness() const
Definition: btCollisionObject.h:361
btCollisionObjectDoubleData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:616
btCollisionObject::m_hitFraction
btScalar m_hitFraction
time of impact calculation
Definition: btCollisionObject.h:107
btCollisionObject::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObject.h:382
btCollisionObject::setHitFraction
void setHitFraction(btScalar hitFraction)
Definition: btCollisionObject.h:482
btCollisionObjectFloatData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:652
btCollisionObject::isKinematicObject
bool isKinematicObject() const
Definition: btCollisionObject.h:200
btCollisionObject::m_contactDamping
btScalar m_contactDamping
Definition: btCollisionObject.h:89
btCollisionObjectDoubleData::m_interpolationLinearVelocity
btVector3DoubleData m_interpolationLinearVelocity
Definition: btCollisionObject.h:622
btCollisionObject::getInterpolationLinearVelocity
const btVector3 & getInterpolationLinearVelocity() const
Definition: btCollisionObject.h:436
btCollisionObject::m_deactivationTime
btScalar m_deactivationTime
Definition: btCollisionObject.h:83
btCollisionObjectFloatData::m_collisionFilterMask
int m_collisionFilterMask
Definition: btCollisionObject.h:678
btCollisionObjectFloatData::m_ccdMotionThreshold
float m_ccdMotionThreshold
Definition: btCollisionObject.h:669
btVector3FloatData
Definition: btVector3.h:1282
btCollisionObjectDoubleData::m_restitution
double m_restitution
Definition: btCollisionObject.h:631
btCollisionObjectFloatData::m_deactivationTime
float m_deactivationTime
Definition: btCollisionObject.h:661
btCollisionObject::m_spinningFriction
btScalar m_spinningFriction
Definition: btCollisionObject.h:88
btCollisionObjectFloatData::m_restitution
float m_restitution
Definition: btCollisionObject.h:666
btCollisionObjectFloatData::m_uniqueId
int m_uniqueId
Definition: btCollisionObject.h:679
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:205
btCollisionObjectDoubleData::m_deactivationTime
double m_deactivationTime
Definition: btCollisionObject.h:626
btCollisionObject::m_internalType
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody,...
Definition: btCollisionObject.h:94
btCollisionObjectFloatData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:650
btCollisionObject::setIgnoreCollisionCheck
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
Definition: btCollisionObject.h:236
btCollisionObject::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:63
btCollisionObjectFloatData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:651
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:377
btCollisionObject::checkCollideWith
bool checkCollideWith(const btCollisionObject *co) const
Definition: btCollisionObject.h:594
btCollisionObject::getObjectWithoutCollision
const btCollisionObject * getObjectWithoutCollision(int index)
Definition: btCollisionObject.h:259
btCollisionShape
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
Definition: btCollisionShape.h:28
ISLAND_SLEEPING
#define ISLAND_SLEEPING
Definition: btCollisionObject.h:23
btCollisionObjectDoubleData::m_contactDamping
double m_contactDamping
Definition: btCollisionObject.h:629
btCollisionObject::setRestitution
void setRestitution(btScalar rest)
Definition: btCollisionObject.h:309
btCollisionObject::m_collisionShape
btCollisionShape * m_collisionShape
Definition: btCollisionObject.h:67
btCollisionObject::setUserIndex3
void setUserIndex3(int index)
Definition: btCollisionObject.h:563
btCollisionObject::m_worldArrayIndex
int m_worldArrayIndex
Definition: btCollisionObject.h:80
btVector3DoubleData
Definition: btVector3.h:1287
btCollisionObject::getCcdSquareMotionThreshold
btScalar getCcdSquareMotionThreshold() const
Definition: btCollisionObject.h:514
btCollisionObject::setCcdSweptSphereRadius
void setCcdSweptSphereRadius(btScalar radius)
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:504
btCollisionObject::setCollisionShape
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition: btCollisionObject.h:219
btCollisionObject::m_anisotropicFriction
btVector3 m_anisotropicFriction
Definition: btCollisionObject.h:62
btCollisionObject::m_rootCollisionShape
btCollisionShape * m_rootCollisionShape
m_rootCollisionShape is temporarily used to store the original collision shape The m_collisionShape m...
Definition: btCollisionObject.h:74
btCollisionObjectFloatData::m_rollingFriction
float m_rollingFriction
Definition: btCollisionObject.h:663
btCollisionObject::setSpinningFriction
void setSpinningFriction(btScalar frict)
Definition: btCollisionObject.h:337
btCollisionObject::setUserIndex
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:553
btCollisionObject::getDeactivationTime
btScalar getDeactivationTime() const
Definition: btCollisionObject.h:295
btCollisionObjectFloatData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:674
btAlignedAllocator.h
btCollisionObjectFloatData::m_worldTransform
btTransformFloatData m_worldTransform
Definition: btCollisionObject.h:655
btCollisionObject::getAnisotropicFriction
const btVector3 & getAnisotropicFriction() const
Definition: btCollisionObject.h:169
btCollisionObject::m_customDebugColorRGB
btVector3 m_customDebugColorRGB
Definition: btCollisionObject.h:123
btCollisionObjectFloatData::m_interpolationAngularVelocity
btVector3FloatData m_interpolationAngularVelocity
Definition: btCollisionObject.h:658
btCollisionObject::m_userIndex3
int m_userIndex3
Definition: btCollisionObject.h:104
btCollisionObject::getBroadphaseHandle
btBroadphaseProxy * getBroadphaseHandle()
Definition: btCollisionObject.h:393
btCollisionObject::setFriction
void setFriction(btScalar frict)
Definition: btCollisionObject.h:318
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:408
btCollisionObject::setWorldTransform
void setWorldTransform(const btTransform &worldTrans)
Definition: btCollisionObject.h:387
btCollisionObject::getRollingFriction
btScalar getRollingFriction() const
Definition: btCollisionObject.h:333
btTransform.h
btCollisionObject::getUserIndex3
int getUserIndex3() const
Definition: btCollisionObject.h:541
btCollisionObject::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btCollisionObject.h:683
btCollisionObject::setCompanionId
void setCompanionId(int id)
Definition: btCollisionObject.h:461
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btCollisionObject::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:82
btCollisionObject::getUserIndex
int getUserIndex() const
Definition: btCollisionObject.h:531
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:487
btCollisionObject::setDeactivationTime
void setDeactivationTime(btScalar time)
Definition: btCollisionObject.h:291
btCollisionObjectFloatData::m_anisotropicFriction
btVector3FloatData m_anisotropicFriction
Definition: btCollisionObject.h:659
btCollisionObject::isStaticObject
bool isStaticObject() const
Definition: btCollisionObject.h:195
btCollisionObject::setInterpolationAngularVelocity
void setInterpolationAngularVelocity(const btVector3 &angvel)
Definition: btCollisionObject.h:430
btCollisionObject::setInterpolationWorldTransform
void setInterpolationWorldTransform(const btTransform &trans)
Definition: btCollisionObject.h:418
btCollisionObjectDoubleData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:639
btCollisionObject::getRestitution
btScalar getRestitution() const
Definition: btCollisionObject.h:314
btCollisionObject::getInterpolationWorldTransform
btTransform & getInterpolationWorldTransform()
Definition: btCollisionObject.h:413
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
btCollisionObject::getContactProcessingThreshold
btScalar getContactProcessingThreshold() const
Definition: btCollisionObject.h:190
btCollisionObject::m_rollingFriction
btScalar m_rollingFriction
Definition: btCollisionObject.h:87
btCollisionObject::setAnisotropicFriction
void setAnisotropicFriction(const btVector3 &anisotropicFriction, int frictionMode=CF_ANISOTROPIC_FRICTION)
Definition: btCollisionObject.h:173
btCollisionObject::hasContactResponse
bool hasContactResponse() const
Definition: btCollisionObject.h:210
btCollisionObject::m_extensionPointer
void * m_extensionPointer
m_extensionPointer is used by some internal low-level Bullet extensions.
Definition: btCollisionObject.h:69
btCollisionObject::setUserPointer
void setUserPointer(void *userPointer)
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:547
btCollisionObjectArray
btAlignedObjectArray< class btCollisionObject * > btCollisionObjectArray
Definition: btCollisionObject.h:30
btCollisionObject::getCcdMotionThreshold
btScalar getCcdMotionThreshold() const
Definition: btCollisionObject.h:509
btCollisionObjectFloatData::m_companionId
int m_companionId
Definition: btCollisionObject.h:673
btCollisionObject::m_contactProcessingThreshold
btScalar m_contactProcessingThreshold
Definition: btCollisionObject.h:64
btCollisionObjectDoubleData::m_contactProcessingThreshold
double m_contactProcessingThreshold
Definition: btCollisionObject.h:625
btCollisionObject::getWorldArrayIndex
int getWorldArrayIndex() const
Definition: btCollisionObject.h:466
btCollisionObject::getIslandTag
int getIslandTag() const
Definition: btCollisionObject.h:446
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:99
btCollisionObject::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:76
btCollisionObject::m_interpolationAngularVelocity
btVector3 m_interpolationAngularVelocity
Definition: btCollisionObject.h:60
btCollisionObject::m_updateRevision
int m_updateRevision
internal update revision number. It will be increased when the object changes. This allows some subsy...
Definition: btCollisionObject.h:121
btTransformFloatData
for serialization
Definition: btTransform.h:245
btAlignedObjectArray
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
Definition: btAlignedObjectArray.h:46
btCollisionObject::internalGetExtensionPointer
void * internalGetExtensionPointer() const
Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
Definition: btCollisionObject.h:276
btCollisionObjectFloatData::m_contactProcessingThreshold
float m_contactProcessingThreshold
Definition: btCollisionObject.h:660
btCollisionObject::CollisionFlags
CollisionFlags
Definition: btCollisionObject.h:129
btCollisionObjectDoubleData::m_ccdSweptSphereRadius
double m_ccdSweptSphereRadius
Definition: btCollisionObject.h:633
btCollisionObjectDoubleData::m_contactStiffness
double m_contactStiffness
Definition: btCollisionObject.h:630
btCollisionObject::setRollingFriction
void setRollingFriction(btScalar frict)
Definition: btCollisionObject.h:328
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:98
btCollisionObject::getCollisionShape
btCollisionShape * getCollisionShape()
Definition: btCollisionObject.h:231
btCollisionObject::internalSetExtensionPointer
void internalSetExtensionPointer(void *pointer)
Avoid using this internal API call, the extension pointer is used by some Bullet extensions If you ne...
Definition: btCollisionObject.h:282
btSerializer
Definition: btSerializer.h:66
btCollisionObject::CollisionObjectTypes
CollisionObjectTypes
Definition: btCollisionObject.h:144
btCollisionObject::setBroadphaseHandle
void setBroadphaseHandle(btBroadphaseProxy *handle)
Definition: btCollisionObject.h:403
btCollisionObjectFloatData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:670
btCollisionObject::m_restitution
btScalar m_restitution
Definition: btCollisionObject.h:86
btCollisionObject::setCollisionFlags
void setCollisionFlags(int flags)
Definition: btCollisionObject.h:492
btCollisionObject::setInterpolationLinearVelocity
void setInterpolationLinearVelocity(const btVector3 &linvel)
Definition: btCollisionObject.h:424
btCollisionObject::getHitFraction
btScalar getHitFraction() const
Definition: btCollisionObject.h:477
btCollisionObject::getSpinningFriction
btScalar getSpinningFriction() const
Definition: btCollisionObject.h:342
btCollisionObjectDoubleData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:636
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:372
btCollisionObject::m_broadphaseHandle
btBroadphaseProxy * m_broadphaseHandle
Definition: btCollisionObject.h:66
btCollisionObject::setIslandTag
void setIslandTag(int tag)
Definition: btCollisionObject.h:451
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:304
btCollisionObjectDoubleData::m_name
char * m_name
Definition: btCollisionObject.h:618
btCollisionObjectFloatData::m_friction
float m_friction
Definition: btCollisionObject.h:662
btCollisionObjectDoubleData::m_interpolationAngularVelocity
btVector3DoubleData m_interpolationAngularVelocity
Definition: btCollisionObject.h:623
btCollisionObject::m_checkCollideWith
int m_checkCollideWith
If some object should have elaborate collision filtering by sub-classes.
Definition: btCollisionObject.h:116
btCollisionObject::getNumObjectsWithoutCollision
int getNumObjectsWithoutCollision() const
Definition: btCollisionObject.h:254
btCollisionObjectDoubleData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:635
btCollisionObject::getCustomDebugColor
bool getCustomDebugColor(btVector3 &colorRGB) const
Definition: btCollisionObject.h:584
btAlignedObjectArray.h
btCollisionObjectFloatData::m_contactDamping
float m_contactDamping
Definition: btCollisionObject.h:664
btCollisionObject::getCcdSweptSphereRadius
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:498
btCollisionObject::setContactProcessingThreshold
void setContactProcessingThreshold(btScalar contactProcessingThreshold)
the constraint solver can discard solving contacts, if the distance is above this threshold.
Definition: btCollisionObject.h:186
btCollisionObject::m_contactStiffness
btScalar m_contactStiffness
Definition: btCollisionObject.h:90
btCollisionObject::hasAnisotropicFriction
bool hasAnisotropicFriction(int frictionMode=CF_ANISOTROPIC_FRICTION) const
Definition: btCollisionObject.h:179
btCollisionObjectFloatData::m_contactStiffness
float m_contactStiffness
Definition: btCollisionObject.h:665
btCollisionObject::m_userObjectPointer
void * m_userObjectPointer
users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPoin...
Definition: btCollisionObject.h:98
btCollisionObjectFloatData::m_hitFraction
float m_hitFraction
Definition: btCollisionObject.h:667
btCollisionObjectDoubleData::m_anisotropicFriction
btVector3DoubleData m_anisotropicFriction
Definition: btCollisionObject.h:624
btCollisionObject::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:78
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:257
btCollisionObjectDoubleData::m_hitFraction
double m_hitFraction
Definition: btCollisionObject.h:632
btCollisionObjectDoubleData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:617
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:480
btCollisionObjectFloatData::m_interpolationLinearVelocity
btVector3FloatData m_interpolationLinearVelocity
Definition: btCollisionObject.h:657
btCollisionObject::getFriction
btScalar getFriction() const
Definition: btCollisionObject.h:323
btCollisionObjectFloatData::m_ccdSweptSphereRadius
float m_ccdSweptSphereRadius
Definition: btCollisionObject.h:668
btCollisionObject::m_interpolationLinearVelocity
btVector3 m_interpolationLinearVelocity
Definition: btCollisionObject.h:59
btCollisionObject::getUserPointer
void * getUserPointer() const
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:526
btCollisionObjectDoubleData::m_collisionFilterGroup
int m_collisionFilterGroup
Definition: btCollisionObject.h:642
btCollisionObjectDoubleData::m_internalType
int m_internalType
Definition: btCollisionObject.h:640
btCollisionObject::setUserIndex2
void setUserIndex2(int index)
Definition: btCollisionObject.h:558
btCollisionObject::BT_DECLARE_ALIGNED_ALLOCATOR
BT_DECLARE_ALIGNED_ALLOCATOR()
btCollisionObjectDoubleData::m_friction
double m_friction
Definition: btCollisionObject.h:627
btCollisionObject::m_companionId
int m_companionId
Definition: btCollisionObject.h:79
btCollisionObject::m_friction
btScalar m_friction
Definition: btCollisionObject.h:85
btCollisionObject::m_userIndex2
int m_userIndex2
Definition: btCollisionObject.h:100
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:142
btCollisionObject::getInterpolationAngularVelocity
const btVector3 & getInterpolationAngularVelocity() const
Definition: btCollisionObject.h:441
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:226
btCollisionObjectDoubleData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:641
btCollisionObject::getCompanionId
int getCompanionId() const
Definition: btCollisionObject.h:456