Bullet Collision Detection & Physics Library
btCollisionObject.h
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. 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
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
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{
51protected:
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
125public:
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
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
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
282 {
283 m_deactivationTime = time;
284 }
286 {
287 return m_deactivationTime;
288 }
289
290 void forceActivationState(int newState) const;
291
292 void activate(bool forceActivation = false) const;
293
295 {
296 return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
297 }
298
300 {
301 m_updateRevision++;
302 m_restitution = rest;
303 }
305 {
306 return m_restitution;
307 }
309 {
310 m_updateRevision++;
311 m_friction = frict;
312 }
314 {
315 return m_friction;
316 }
317
319 {
320 m_updateRevision++;
321 m_rollingFriction = frict;
322 }
324 {
325 return m_rollingFriction;
326 }
328 {
329 m_updateRevision++;
330 m_spinningFriction = frict;
331 }
333 {
334 return m_spinningFriction;
335 }
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
352 {
353 return m_contactStiffness;
354 }
355
357 {
358 return m_contactDamping;
359 }
360
362 int getInternalType() const
363 {
364 return m_internalType;
365 }
366
368 {
369 return m_worldTransform;
370 }
371
373 {
374 return m_worldTransform;
375 }
376
377 void setWorldTransform(const btTransform& worldTrans)
378 {
379 m_updateRevision++;
380 m_worldTransform = worldTrans;
381 }
382
384 {
385 return m_broadphaseHandle;
386 }
387
389 {
390 return m_broadphaseHandle;
391 }
392
394 {
395 m_broadphaseHandle = handle;
396 }
397
399 {
400 return m_interpolationWorldTransform;
401 }
402
404 {
405 return m_interpolationWorldTransform;
406 }
407
409 {
410 m_updateRevision++;
411 m_interpolationWorldTransform = trans;
412 }
413
415 {
416 m_updateRevision++;
417 m_interpolationLinearVelocity = linvel;
418 }
419
421 {
422 m_updateRevision++;
423 m_interpolationAngularVelocity = angvel;
424 }
425
427 {
428 return m_interpolationLinearVelocity;
429 }
430
432 {
433 return m_interpolationAngularVelocity;
434 }
435
437 {
438 return m_islandTag1;
439 }
440
441 void setIslandTag(int tag)
442 {
443 m_islandTag1 = tag;
444 }
445
447 {
448 return m_companionId;
449 }
450
451 void setCompanionId(int id)
452 {
453 m_companionId = id;
454 }
455
457 {
458 return m_worldArrayIndex;
459 }
460
461 // only should be called by CollisionWorld
463 {
464 m_worldArrayIndex = ix;
465 }
466
468 {
469 return m_hitFraction;
470 }
471
472 void setHitFraction(btScalar hitFraction)
473 {
474 m_hitFraction = hitFraction;
475 }
476
478 {
479 return m_collisionFlags;
480 }
481
482 void setCollisionFlags(int flags)
483 {
484 m_collisionFlags = flags;
485 }
486
489 {
490 return m_ccdSweptSphereRadius;
491 }
492
495 {
496 m_ccdSweptSphereRadius = radius;
497 }
498
500 {
501 return m_ccdMotionThreshold;
502 }
503
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
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
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
604{
608 char *m_name;
609
634 int m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
635};
636
639{
643 char *m_name;
644
670};
671// clang-format on
672
674{
675 return sizeof(btCollisionObjectData);
676}
677
678#endif //BT_COLLISION_OBJECT_H
#define btCollisionObjectData
btAlignedObjectArray< class btCollisionObject * > btCollisionObjectArray
#define ISLAND_SLEEPING
#define DISABLE_SIMULATION
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:99
#define SIMD_FORCE_INLINE
Definition: btScalar.h:98
#define SIMD_EPSILON
Definition: btScalar.h:543
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
int size() const
return the number of elements in the array
int findLinearSearch(const T &key) const
void remove(const T &key)
void push_back(const T &_Val)
btCollisionObject can be used to manage collision detection objects.
btScalar getContactStiffness() const
const btBroadphaseProxy * getBroadphaseHandle() const
void setRestitution(btScalar rest)
int m_updateRevision
internal update revision number. It will be increased when the object changes. This allows some subsy...
virtual bool checkCollideWithOverride(const btCollisionObject *co) const
void setSpinningFriction(btScalar frict)
const btTransform & getWorldTransform() const
bool isStaticOrKinematicObject() const
btScalar getHitFraction() const
void setAnisotropicFriction(const btVector3 &anisotropicFriction, int frictionMode=CF_ANISOTROPIC_FRICTION)
void setWorldArrayIndex(int ix)
void setCollisionFlags(int flags)
btTransform & getWorldTransform()
int m_checkCollideWith
If some object should have elaborate collision filtering by sub-classes.
btBroadphaseProxy * getBroadphaseHandle()
int getUserIndex3() const
const btVector3 & getAnisotropicFriction() const
btTransform m_worldTransform
btCollisionShape * m_collisionShape
int getUserIndex2() const
void setUserPointer(void *userPointer)
users can point to their objects, userPointer is not used by Bullet
int getInternalType() const
reserved for Bullet internal usage
int getUserIndex() const
virtual void setCollisionShape(btCollisionShape *collisionShape)
btScalar getDeactivationTime() const
bool hasContactResponse() const
btVector3 m_interpolationLinearVelocity
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
btScalar getSpinningFriction() const
void * getUserPointer() const
users can point to their objects, userPointer is not used by Bullet
bool isStaticObject() const
void setContactProcessingThreshold(btScalar contactProcessingThreshold)
the constraint solver can discard solving contacts, if the distance is above this threshold.
btCollisionShape * m_rootCollisionShape
m_rootCollisionShape is temporarily used to store the original collision shape The m_collisionShape m...
void * m_extensionPointer
m_extensionPointer is used by some internal low-level Bullet extensions.
btTransform & getInterpolationWorldTransform()
bool checkCollideWith(const btCollisionObject *co) const
btVector3 m_interpolationAngularVelocity
bool getCustomDebugColor(btVector3 &colorRGB) const
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody,...
void setWorldTransform(const btTransform &worldTrans)
void * m_userObjectPointer
users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPoin...
void setCustomDebugColor(const btVector3 &colorRGB)
btScalar getFriction() const
btVector3 m_anisotropicFriction
btScalar getContactProcessingThreshold() const
int getWorldArrayIndex() const
btCollisionShape * getCollisionShape()
void setCcdMotionThreshold(btScalar ccdMotionThreshold)
Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
btScalar m_ccdSweptSphereRadius
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
bool hasAnisotropicFriction(int frictionMode=CF_ANISOTROPIC_FRICTION) const
virtual int calculateSerializeBufferSize() const
btTransform m_interpolationWorldTransform
m_interpolationWorldTransform is used for CCD and interpolation it can be either previous or future (...
void setCompanionId(int id)
bool isKinematicObject() const
const btTransform & getInterpolationWorldTransform() const
btScalar getContactDamping() const
int getIslandTag() const
const btCollisionShape * getCollisionShape() const
int getCompanionId() const
void setUserIndex2(int index)
void setFriction(btScalar frict)
void internalSetExtensionPointer(void *pointer)
Avoid using this internal API call, the extension pointer is used by some Bullet extensions If you ne...
btAlignedObjectArray< const btCollisionObject * > m_objectsWithoutCollisionCheck
void setCcdSweptSphereRadius(btScalar radius)
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
void setDeactivationTime(btScalar time)
bool mergesSimulationIslands() const
btScalar m_ccdMotionThreshold
Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
btScalar m_contactProcessingThreshold
void setRollingFriction(btScalar frict)
void setIslandTag(int tag)
void setBroadphaseHandle(btBroadphaseProxy *handle)
btBroadphaseProxy * m_broadphaseHandle
int getCollisionFlags() const
void setInterpolationAngularVelocity(const btVector3 &angvel)
const btVector3 & getInterpolationAngularVelocity() const
btScalar getCcdMotionThreshold() const
void setHitFraction(btScalar hitFraction)
btVector3 m_customDebugColorRGB
void * internalGetExtensionPointer() const
Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
void setInterpolationLinearVelocity(const btVector3 &linvel)
btScalar m_hitFraction
time of impact calculation
int getUpdateRevisionInternal() const
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
btScalar getRestitution() const
int getActivationState() const
btScalar getRollingFriction() const
btScalar getCcdSquareMotionThreshold() const
void setInterpolationWorldTransform(const btTransform &trans)
void setUserIndex3(int index)
const btVector3 & getInterpolationLinearVelocity() const
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3DoubleData m_anisotropicFriction
btVector3DoubleData m_interpolationLinearVelocity
btTransformDoubleData m_interpolationWorldTransform
btTransformDoubleData m_worldTransform
btVector3DoubleData m_interpolationAngularVelocity
btCollisionShapeData * m_rootCollisionShape
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btVector3FloatData m_interpolationLinearVelocity
btVector3FloatData m_anisotropicFriction
btTransformFloatData m_interpolationWorldTransform
btVector3FloatData m_interpolationAngularVelocity
btTransformFloatData m_worldTransform
btCollisionShapeData * m_rootCollisionShape
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
for serialization
Definition: btTransform.h:245