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