Bullet Collision Detection & Physics Library: btCollisionObject.h Source File

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;
30 struct btCollisionShapeData;
31 #include "LinearMath/btMotionState.h"
32 #include "LinearMath/btAlignedAllocator.h"
33 #include "LinearMath/btAlignedObjectArray.h"
34
35 typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
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
48 ATTRIBUTE_ALIGNED16(class)
49 btCollisionObject
50 {
51 protected:
52 btTransform m_worldTransform;
53
56 btTransform m_interpolationWorldTransform;
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)
59 btVector3 m_interpolationLinearVelocity;
60 btVector3 m_interpolationAngularVelocity;
61
62 btVector3 m_anisotropicFriction;
63 int m_hasAnisotropicFriction;
64 btScalar m_contactProcessingThreshold;
65
66 btBroadphaseProxy* m_broadphaseHandle;
67 btCollisionShape* m_collisionShape;
69 void* m_extensionPointer;
70
74 btCollisionShape* m_rootCollisionShape;
75
76 int m_collisionFlags;
77
78 int m_islandTag1;
79 int m_companionId;
80 int m_worldArrayIndex; // index of object in world's collisionObjects array
81
82 mutable int m_activationState1;
83 mutable btScalar m_deactivationTime;
84
85 btScalar m_friction;
86 btScalar m_restitution;
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)
89 btScalar m_contactDamping;
90 btScalar m_contactStiffness;
91
94 int m_internalType;
95
97
98 void* m_userObjectPointer;
99
100 int m_userIndex2;
101
102 int m_userIndex;
103
104 int m_userIndex3;
105
107 btScalar m_hitFraction;
108
110 btScalar m_ccdSweptSphereRadius;
111
113 btScalar m_ccdMotionThreshold;
114
116 int m_checkCollideWith;
117
118 btAlignedObjectArray<const btCollisionObject*> m_objectsWithoutCollisionCheck;
119
121 int m_updateRevision;
122
123 btVector3 m_customDebugColorRGB;
124
125 public:
126 BT_DECLARE_ALIGNED_ALLOCATOR();
127
128 enum CollisionFlags
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
143 enum CollisionObjectTypes
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
156 enum AnisotropicFrictionFlags
157 {
158 CF_ANISOTROPIC_FRICTION_DISABLED = 0,
159 CF_ANISOTROPIC_FRICTION = 1,
160 CF_ANISOTROPIC_ROLLING_FRICTION = 2
161 };
162
163 SIMD_FORCE_INLINE bool mergesSimulationIslands() const
164 {
166 return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE)) == 0);
167 }
168
169 const btVector3& getAnisotropicFriction() const
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 }
190 btScalar getContactProcessingThreshold() const
191 {
192 return m_contactProcessingThreshold;
193 }
194
195 SIMD_FORCE_INLINE bool isStaticObject() const
196 {
197 return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
198 }
199
200 SIMD_FORCE_INLINE bool isKinematicObject() const
201 {
202 return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
203 }
204
205 SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
206 {
207 return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0;
208 }
209
210 SIMD_FORCE_INLINE bool hasContactResponse() const
211 {
212 return (m_collisionFlags & CF_NO_CONTACT_RESPONSE) == 0;
213 }
214
215 btCollisionObject();
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
226 SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
227 {
228 return m_collisionShape;
229 }
230
231 SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
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
266 void* internalGetExtensionPointer() const
267 {
268 return m_extensionPointer;
269 }
272 void internalSetExtensionPointer(void* pointer)
273 {
274 m_extensionPointer = pointer;
275 }
276
277 SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1; }
278
279 void setActivationState(int newState) const;
280
281 void setDeactivationTime(btScalar time)
282 {
283 m_deactivationTime = time;
284 }
285 btScalar getDeactivationTime() const
286 {
287 return m_deactivationTime;
288 }
289
290 void forceActivationState(int newState) const;
291
292 void activate(bool forceActivation = false) const;
293
294 SIMD_FORCE_INLINE bool isActive() const
295 {
296 return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
297 }
298
299 void setRestitution(btScalar rest)
300 {
301 m_updateRevision++;
302 m_restitution = rest;
303 }
304 btScalar getRestitution() const
305 {
306 return m_restitution;
307 }
308 void setFriction(btScalar frict)
309 {
310 m_updateRevision++;
311 m_friction = frict;
312 }
313 btScalar getFriction() const
314 {
315 return m_friction;
316 }
317
318 void setRollingFriction(btScalar frict)
319 {
320 m_updateRevision++;
321 m_rollingFriction = frict;
322 }
323 btScalar getRollingFriction() const
324 {
325 return m_rollingFriction;
326 }
327 void setSpinningFriction(btScalar frict)
328 {
329 m_updateRevision++;
330 m_spinningFriction = frict;
331 }
332 btScalar getSpinningFriction() const
333 {
334 return m_spinningFriction;
335 }
336 void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
337 {
338 m_updateRevision++;
339 m_contactStiffness = stiffness;
340 m_contactDamping = damping;
341
342 m_collisionFlags |= CF_HAS_CONTACT_STIFFNESS_DAMPING;
343
344 //avoid divisions by zero...
345 if (m_contactStiffness < SIMD_EPSILON)
346 {
347 m_contactStiffness = SIMD_EPSILON;
348 }
349 }
350
351 btScalar getContactStiffness() const
352 {
353 return m_contactStiffness;
354 }
355
356 btScalar getContactDamping() const
357 {
358 return m_contactDamping;
359 }
360
362 int getInternalType() const
363 {
364 return m_internalType;
365 }
366
367 btTransform& getWorldTransform()
368 {
369 return m_worldTransform;
370 }
371
372 const btTransform& getWorldTransform() const
373 {
374 return m_worldTransform;
375 }
376
377 void setWorldTransform(const btTransform& worldTrans)
378 {
379 m_updateRevision++;
380 m_worldTransform = worldTrans;
381 }
382
383 SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle()
384 {
385 return m_broadphaseHandle;
386 }
387
388 SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const
389 {
390 return m_broadphaseHandle;
391 }
392
393 void setBroadphaseHandle(btBroadphaseProxy * handle)
394 {
395 m_broadphaseHandle = handle;
396 }
397
398 const btTransform& getInterpolationWorldTransform() const
399 {
400 return m_interpolationWorldTransform;
401 }
402
403 btTransform& getInterpolationWorldTransform()
404 {
405 return m_interpolationWorldTransform;
406 }
407
408 void setInterpolationWorldTransform(const btTransform& trans)
409 {
410 m_updateRevision++;
411 m_interpolationWorldTransform = trans;
412 }
413
414 void setInterpolationLinearVelocity(const btVector3& linvel)
415 {
416 m_updateRevision++;
417 m_interpolationLinearVelocity = linvel;
418 }
419
420 void setInterpolationAngularVelocity(const btVector3& angvel)
421 {
422 m_updateRevision++;
423 m_interpolationAngularVelocity = angvel;
424 }
425
426 const btVector3& getInterpolationLinearVelocity() const
427 {
428 return m_interpolationLinearVelocity;
429 }
430
431 const btVector3& getInterpolationAngularVelocity() const
432 {
433 return m_interpolationAngularVelocity;
434 }
435
436 SIMD_FORCE_INLINE int getIslandTag() const
437 {
438 return m_islandTag1;
439 }
440
441 void setIslandTag(int tag)
442 {
443 m_islandTag1 = tag;
444 }
445
446 SIMD_FORCE_INLINE int getCompanionId() const
447 {
448 return m_companionId;
449 }
450
451 void setCompanionId(int id)
452 {
453 m_companionId = id;
454 }
455
456 SIMD_FORCE_INLINE int getWorldArrayIndex() const
457 {
458 return m_worldArrayIndex;
459 }
460
461 // only should be called by CollisionWorld
462 void setWorldArrayIndex(int ix)
463 {
464 m_worldArrayIndex = ix;
465 }
466
467 SIMD_FORCE_INLINE btScalar getHitFraction() const
468 {
469 return m_hitFraction;
470 }
471
472 void setHitFraction(btScalar hitFraction)
473 {
474 m_hitFraction = hitFraction;
475 }
476
477 SIMD_FORCE_INLINE int getCollisionFlags() const
478 {
479 return m_collisionFlags;
480 }
481
482 void setCollisionFlags(int flags)
483 {
484 m_collisionFlags = flags;
485 }
486
488 btScalar getCcdSweptSphereRadius() const
489 {
490 return m_ccdSweptSphereRadius;
491 }
492
494 void setCcdSweptSphereRadius(btScalar radius)
495 {
496 m_ccdSweptSphereRadius = radius;
497 }
498
499 btScalar getCcdMotionThreshold() const
500 {
501 return m_ccdMotionThreshold;
502 }
503
504 btScalar getCcdSquareMotionThreshold() const
505 {
506 return m_ccdMotionThreshold * m_ccdMotionThreshold;
507 }
508
510 void setCcdMotionThreshold(btScalar ccdMotionThreshold)
511 {
512 m_ccdMotionThreshold = ccdMotionThreshold;
513 }
514
516 void* getUserPointer() const
517 {
518 return m_userObjectPointer;
519 }
520
521 int getUserIndex() const
522 {
523 return m_userIndex;
524 }
525
526 int getUserIndex2() const
527 {
528 return m_userIndex2;
529 }
530
531 int getUserIndex3() const
532 {
533 return m_userIndex3;
534 }
535
537 void setUserPointer(void* userPointer)
538 {
539 m_userObjectPointer = userPointer;
540 }
541
543 void setUserIndex(int index)
544 {
545 m_userIndex = index;
546 }
547
548 void setUserIndex2(int index)
549 {
550 m_userIndex2 = index;
551 }
552
553 void setUserIndex3(int index)
554 {
555 m_userIndex3 = index;
556 }
557
558 int getUpdateRevisionInternal() const
559 {
560 return m_updateRevision;
561 }
562
563 void setCustomDebugColor(const btVector3& colorRGB)
564 {
565 m_customDebugColorRGB = colorRGB;
566 m_collisionFlags |= CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
567 }
568
569 void removeCustomDebugColor()
570 {
571 m_collisionFlags &= ~CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
572 }
573
574 bool getCustomDebugColor(btVector3 & colorRGB) const
575 {
576 bool hasCustomColor = (0 != (m_collisionFlags & CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR));
577 if (hasCustomColor)
578 {
579 colorRGB = m_customDebugColorRGB;
580 }
581 return hasCustomColor;
582 }
583
584 inline bool checkCollideWith(const btCollisionObject* co) const
585 {
586 if (m_checkCollideWith)
587 return checkCollideWithOverride(co);
588
589 return true;
590 }
591
592 virtual int calculateSerializeBufferSize() const;
593
595 virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
596
597 virtual void serializeSingleObject(class btSerializer * serializer) const;
598 };
599
600 // clang-format off
601
603 struct btCollisionObjectDoubleData
604 {
605 void *m_broadphaseHandle;
606 void *m_collisionShape;
607 btCollisionShapeData *m_rootCollisionShape;
608 char *m_name;
609
610 btTransformDoubleData m_worldTransform;
611 btTransformDoubleData m_interpolationWorldTransform;
612 btVector3DoubleData m_interpolationLinearVelocity;
613 btVector3DoubleData m_interpolationAngularVelocity;
614 btVector3DoubleData m_anisotropicFriction;
615 double m_contactProcessingThreshold;
616 double m_deactivationTime;
617 double m_friction;
618 double m_rollingFriction;
619 double m_contactDamping;
620 double m_contactStiffness;
621 double m_restitution;
622 double m_hitFraction;
623 double m_ccdSweptSphereRadius;
624 double m_ccdMotionThreshold;
625 int m_hasAnisotropicFriction;
626 int m_collisionFlags;
627 int m_islandTag1;
628 int m_companionId;
629 int m_activationState1;
630 int m_internalType;
631 int m_checkCollideWith;
632 int m_collisionFilterGroup;
633 int m_collisionFilterMask;
634 int m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
635 };
636
638 struct btCollisionObjectFloatData
639 {
640 void *m_broadphaseHandle;
641 void *m_collisionShape;
642 btCollisionShapeData *m_rootCollisionShape;
643 char *m_name;
644
645 btTransformFloatData m_worldTransform;
646 btTransformFloatData m_interpolationWorldTransform;
647 btVector3FloatData m_interpolationLinearVelocity;
648 btVector3FloatData m_interpolationAngularVelocity;
649 btVector3FloatData m_anisotropicFriction;
650 float m_contactProcessingThreshold;
651 float m_deactivationTime;
652 float m_friction;
653 float m_rollingFriction;
654 float m_contactDamping;
655 float m_contactStiffness;
656 float m_restitution;
657 float m_hitFraction;
658 float m_ccdSweptSphereRadius;
659 float m_ccdMotionThreshold;
660 int m_hasAnisotropicFriction;
661 int m_collisionFlags;
662 int m_islandTag1;
663 int m_companionId;
664 int m_activationState1;
665 int m_internalType;
666 int m_checkCollideWith;
667 int m_collisionFilterGroup;
668 int m_collisionFilterMask;
669 int m_uniqueId;
670 };
671 // clang-format on
672
673 SIMD_FORCE_INLINE int btCollisionObject::calculateSerializeBufferSize() const
674 {
675 return sizeof(btCollisionObjectData);
676 }
677
678 #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:152
btCollisionObject::checkCollideWithOverride
virtual bool checkCollideWithOverride(const btCollisionObject *co) const
Definition: btCollisionObject.h:254
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:633
btCollisionObject::getContactDamping
btScalar getContactDamping() const
Definition: btCollisionObject.h:356
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:526
btCollisionObjectDoubleData::m_ccdMotionThreshold
double m_ccdMotionThreshold
Definition: btCollisionObject.h:624
btCollisionObject::getUpdateRevisionInternal
int getUpdateRevisionInternal() const
Definition: btCollisionObject.h:558
btCollisionObjectFloatData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:661
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:666
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:627
btCollisionObject::AnisotropicFrictionFlags
AnisotropicFrictionFlags
Definition: btCollisionObject.h:157
btCollisionObject::setContactStiffnessAndDamping
void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
Definition: btCollisionObject.h:336
btCollisionObjectDoubleData::m_uniqueId
int m_uniqueId
Definition: btCollisionObject.h:634
btCollisionObject::getBroadphaseHandle
const btBroadphaseProxy * getBroadphaseHandle() const
Definition: btCollisionObject.h:388
btCollisionObjectFloatData::m_internalType
int m_internalType
Definition: btCollisionObject.h:665
btCollisionObjectFloatData::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:662
btCollisionObjectFloatData::m_name
char * m_name
Definition: btCollisionObject.h:643
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:667
btCollisionObjectDoubleData::m_rollingFriction
double m_rollingFriction
Definition: btCollisionObject.h:618
btCollisionObjectDoubleData::m_companionId
int m_companionId
Definition: btCollisionObject.h:628
btCollisionObjectDoubleData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btCollisionObject.h:604
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:510
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:639
btCollisionObject::setWorldArrayIndex
void setWorldArrayIndex(int ix)
Definition: btCollisionObject.h:462
btCollisionObjectDoubleData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:605
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:569
btCollisionObjectFloatData::m_interpolationWorldTransform
btTransformFloatData m_interpolationWorldTransform
Definition: btCollisionObject.h:646
btCollisionObjectData
#define btCollisionObjectData
Definition: btCollisionObject.h:41
btCollisionObject::getActivationState
int getActivationState() const
Definition: btCollisionObject.h:277
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition: btCollisionObject.h:52
btCollisionObjectDoubleData::m_interpolationWorldTransform
btTransformDoubleData m_interpolationWorldTransform
Definition: btCollisionObject.h:611
btCollisionObject::setCustomDebugColor
void setCustomDebugColor(const btVector3 &colorRGB)
Definition: btCollisionObject.h:563
btCollisionObjectDoubleData::m_worldTransform
btTransformDoubleData m_worldTransform
Definition: btCollisionObject.h:610
btCollisionObject::getContactStiffness
btScalar getContactStiffness() const
Definition: btCollisionObject.h:351
btCollisionObjectDoubleData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:606
btCollisionObject::m_hitFraction
btScalar m_hitFraction
time of impact calculation
Definition: btCollisionObject.h:107
btCollisionObject::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObject.h:372
btCollisionObject::setHitFraction
void setHitFraction(btScalar hitFraction)
Definition: btCollisionObject.h:472
btCollisionObjectFloatData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:642
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:612
btCollisionObject::getInterpolationLinearVelocity
const btVector3 & getInterpolationLinearVelocity() const
Definition: btCollisionObject.h:426
btCollisionObject::m_deactivationTime
btScalar m_deactivationTime
Definition: btCollisionObject.h:83
btCollisionObjectFloatData::m_collisionFilterMask
int m_collisionFilterMask
Definition: btCollisionObject.h:668
btCollisionObjectFloatData::m_ccdMotionThreshold
float m_ccdMotionThreshold
Definition: btCollisionObject.h:659
btVector3FloatData
Definition: btVector3.h:1282
btCollisionObjectDoubleData::m_restitution
double m_restitution
Definition: btCollisionObject.h:621
btCollisionObjectFloatData::m_deactivationTime
float m_deactivationTime
Definition: btCollisionObject.h:651
btCollisionObject::m_spinningFriction
btScalar m_spinningFriction
Definition: btCollisionObject.h:88
btCollisionObjectFloatData::m_restitution
float m_restitution
Definition: btCollisionObject.h:656
btCollisionObjectFloatData::m_uniqueId
int m_uniqueId
Definition: btCollisionObject.h:669
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:205
btCollisionObjectDoubleData::m_deactivationTime
double m_deactivationTime
Definition: btCollisionObject.h:616
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:640
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:641
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:367
btCollisionObject::checkCollideWith
bool checkCollideWith(const btCollisionObject *co) const
Definition: btCollisionObject.h:584
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:619
btCollisionObject::setRestitution
void setRestitution(btScalar rest)
Definition: btCollisionObject.h:299
btCollisionObject::m_collisionShape
btCollisionShape * m_collisionShape
Definition: btCollisionObject.h:67
btCollisionObject::setUserIndex3
void setUserIndex3(int index)
Definition: btCollisionObject.h:553
btCollisionObject::m_worldArrayIndex
int m_worldArrayIndex
Definition: btCollisionObject.h:80
btVector3DoubleData
Definition: btVector3.h:1287
btCollisionObject::getCcdSquareMotionThreshold
btScalar getCcdSquareMotionThreshold() const
Definition: btCollisionObject.h:504
btCollisionObject::setCcdSweptSphereRadius
void setCcdSweptSphereRadius(btScalar radius)
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:494
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:653
btCollisionObject::setSpinningFriction
void setSpinningFriction(btScalar frict)
Definition: btCollisionObject.h:327
btCollisionObject::setUserIndex
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:543
btCollisionObject::getDeactivationTime
btScalar getDeactivationTime() const
Definition: btCollisionObject.h:285
btCollisionObjectFloatData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:664
btAlignedAllocator.h
btCollisionObjectFloatData::m_worldTransform
btTransformFloatData m_worldTransform
Definition: btCollisionObject.h:645
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:648
btCollisionObject::m_userIndex3
int m_userIndex3
Definition: btCollisionObject.h:104
btCollisionObject::getBroadphaseHandle
btBroadphaseProxy * getBroadphaseHandle()
Definition: btCollisionObject.h:383
btCollisionObject::setFriction
void setFriction(btScalar frict)
Definition: btCollisionObject.h:308
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:398
btCollisionObject::setWorldTransform
void setWorldTransform(const btTransform &worldTrans)
Definition: btCollisionObject.h:377
btCollisionObject::getRollingFriction
btScalar getRollingFriction() const
Definition: btCollisionObject.h:323
btTransform.h
btCollisionObject::getUserIndex3
int getUserIndex3() const
Definition: btCollisionObject.h:531
btCollisionObject::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btCollisionObject.h:673
btCollisionObject::setCompanionId
void setCompanionId(int id)
Definition: btCollisionObject.h:451
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:521
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:477
btCollisionObject::setDeactivationTime
void setDeactivationTime(btScalar time)
Definition: btCollisionObject.h:281
btCollisionObjectFloatData::m_anisotropicFriction
btVector3FloatData m_anisotropicFriction
Definition: btCollisionObject.h:649
btCollisionObject::isStaticObject
bool isStaticObject() const
Definition: btCollisionObject.h:195
btCollisionObject::setInterpolationAngularVelocity
void setInterpolationAngularVelocity(const btVector3 &angvel)
Definition: btCollisionObject.h:420
btCollisionObject::setInterpolationWorldTransform
void setInterpolationWorldTransform(const btTransform &trans)
Definition: btCollisionObject.h:408
btCollisionObjectDoubleData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:629
btCollisionObject::getRestitution
btScalar getRestitution() const
Definition: btCollisionObject.h:304
btCollisionObject::getInterpolationWorldTransform
btTransform & getInterpolationWorldTransform()
Definition: btCollisionObject.h:403
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:537
btCollisionObjectArray
btAlignedObjectArray< class btCollisionObject * > btCollisionObjectArray
Definition: btCollisionObject.h:30
btCollisionObject::getCcdMotionThreshold
btScalar getCcdMotionThreshold() const
Definition: btCollisionObject.h:499
btCollisionObjectFloatData::m_companionId
int m_companionId
Definition: btCollisionObject.h:663
btCollisionObject::m_contactProcessingThreshold
btScalar m_contactProcessingThreshold
Definition: btCollisionObject.h:64
btCollisionObjectDoubleData::m_contactProcessingThreshold
double m_contactProcessingThreshold
Definition: btCollisionObject.h:615
btCollisionObject::getWorldArrayIndex
int getWorldArrayIndex() const
Definition: btCollisionObject.h:456
btCollisionObject::getIslandTag
int getIslandTag() const
Definition: btCollisionObject.h:436
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:266
btCollisionObjectFloatData::m_contactProcessingThreshold
float m_contactProcessingThreshold
Definition: btCollisionObject.h:650
btCollisionObject::CollisionFlags
CollisionFlags
Definition: btCollisionObject.h:129
btCollisionObjectDoubleData::m_ccdSweptSphereRadius
double m_ccdSweptSphereRadius
Definition: btCollisionObject.h:623
btCollisionObjectDoubleData::m_contactStiffness
double m_contactStiffness
Definition: btCollisionObject.h:620
btCollisionObject::setRollingFriction
void setRollingFriction(btScalar frict)
Definition: btCollisionObject.h:318
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:272
btSerializer
Definition: btSerializer.h:66
btCollisionObject::CollisionObjectTypes
CollisionObjectTypes
Definition: btCollisionObject.h:144
btCollisionObject::setBroadphaseHandle
void setBroadphaseHandle(btBroadphaseProxy *handle)
Definition: btCollisionObject.h:393
btCollisionObjectFloatData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:660
btCollisionObject::m_restitution
btScalar m_restitution
Definition: btCollisionObject.h:86
btCollisionObject::setCollisionFlags
void setCollisionFlags(int flags)
Definition: btCollisionObject.h:482
btCollisionObject::setInterpolationLinearVelocity
void setInterpolationLinearVelocity(const btVector3 &linvel)
Definition: btCollisionObject.h:414
btCollisionObject::getHitFraction
btScalar getHitFraction() const
Definition: btCollisionObject.h:467
btCollisionObject::getSpinningFriction
btScalar getSpinningFriction() const
Definition: btCollisionObject.h:332
btCollisionObjectDoubleData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:626
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:362
btCollisionObject::m_broadphaseHandle
btBroadphaseProxy * m_broadphaseHandle
Definition: btCollisionObject.h:66
btCollisionObject::setIslandTag
void setIslandTag(int tag)
Definition: btCollisionObject.h:441
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:294
btCollisionObjectDoubleData::m_name
char * m_name
Definition: btCollisionObject.h:608
btCollisionObjectFloatData::m_friction
float m_friction
Definition: btCollisionObject.h:652
btCollisionObjectDoubleData::m_interpolationAngularVelocity
btVector3DoubleData m_interpolationAngularVelocity
Definition: btCollisionObject.h:613
btCollisionObject::m_checkCollideWith
int m_checkCollideWith
If some object should have elaborate collision filtering by sub-classes.
Definition: btCollisionObject.h:116
btCollisionObjectDoubleData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:625
btCollisionObject::getCustomDebugColor
bool getCustomDebugColor(btVector3 &colorRGB) const
Definition: btCollisionObject.h:574
btAlignedObjectArray.h
btCollisionObjectFloatData::m_contactDamping
float m_contactDamping
Definition: btCollisionObject.h:654
btCollisionObject::getCcdSweptSphereRadius
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:488
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:655
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:657
btCollisionObjectDoubleData::m_anisotropicFriction
btVector3DoubleData m_anisotropicFriction
Definition: btCollisionObject.h:614
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:622
btCollisionObjectDoubleData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:607
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:480
btCollisionObjectFloatData::m_interpolationLinearVelocity
btVector3FloatData m_interpolationLinearVelocity
Definition: btCollisionObject.h:647
btCollisionObject::getFriction
btScalar getFriction() const
Definition: btCollisionObject.h:313
btCollisionObjectFloatData::m_ccdSweptSphereRadius
float m_ccdSweptSphereRadius
Definition: btCollisionObject.h:658
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:516
btCollisionObjectDoubleData::m_collisionFilterGroup
int m_collisionFilterGroup
Definition: btCollisionObject.h:632
btCollisionObjectDoubleData::m_internalType
int m_internalType
Definition: btCollisionObject.h:630
btCollisionObject::setUserIndex2
void setUserIndex2(int index)
Definition: btCollisionObject.h:548
btCollisionObject::BT_DECLARE_ALIGNED_ALLOCATOR
BT_DECLARE_ALIGNED_ALLOCATOR()
btCollisionObjectDoubleData::m_friction
double m_friction
Definition: btCollisionObject.h:617
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:431
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:226
btCollisionObjectDoubleData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:631
btCollisionObject::getCompanionId
int getCompanionId() const
Definition: btCollisionObject.h:446