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
83 mutable int m_activationState1;
84 mutable btScalar m_deactivationTime;
85
86 btScalar m_friction;
87 btScalar m_restitution;
88 btScalar m_rollingFriction;//torsional friction orthogonal to contact normal (useful to stop spheres rolling forever)
89 btScalar m_spinningFriction; // torsional friction around the contact normal (useful for grasping)
90 btScalar m_contactDamping;
91 btScalar m_contactStiffness;
92
93
94
97 int m_internalType;
98
100
101 void* m_userObjectPointer;
102
103 int m_userIndex2;
104
105 int m_userIndex;
106
108 btScalar m_hitFraction;
109
111 btScalar m_ccdSweptSphereRadius;
112
114 btScalar m_ccdMotionThreshold;
115
117 int m_checkCollideWith;
118
119 btAlignedObjectArray<const btCollisionObject*> m_objectsWithoutCollisionCheck;
120
122 int m_updateRevision;
123
124
125 public:
126
127 BT_DECLARE_ALIGNED_ALLOCATOR();
128
129 enum CollisionFlags
130 {
131 CF_STATIC_OBJECT= 1,
132 CF_KINEMATIC_OBJECT= 2,
133 CF_NO_CONTACT_RESPONSE = 4,
134 CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
135 CF_CHARACTER_OBJECT = 16,
136 CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing
137 CF_DISABLE_SPU_COLLISION_PROCESSING = 64,//disable parallel/SPU processing
138 CF_HAS_CONTACT_STIFFNESS_DAMPING = 128
139 };
140
141 enum CollisionObjectTypes
142 {
143 CO_COLLISION_OBJECT =1,
144 CO_RIGID_BODY=2,
147 CO_GHOST_OBJECT=4,
148 CO_SOFT_BODY=8,
149 CO_HF_FLUID=16,
150 CO_USER_TYPE=32,
151 CO_FEATHERSTONE_LINK=64
152 };
153
154 enum AnisotropicFrictionFlags
155 {
156 CF_ANISOTROPIC_FRICTION_DISABLED=0,
157 CF_ANISOTROPIC_FRICTION = 1,
158 CF_ANISOTROPIC_ROLLING_FRICTION = 2
159 };
160
161 SIMD_FORCE_INLINE bool mergesSimulationIslands() const
162 {
164 return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE) )==0);
165 }
166
167 const btVector3& getAnisotropicFriction() const
168 {
169 return m_anisotropicFriction;
170 }
171 void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
172 {
173 m_anisotropicFriction = anisotropicFriction;
174 bool isUnity = (anisotropicFriction[0]!=1.f) || (anisotropicFriction[1]!=1.f) || (anisotropicFriction[2]!=1.f);
175 m_hasAnisotropicFriction = isUnity?frictionMode : 0;
176 }
177 bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const
178 {
179 return (m_hasAnisotropicFriction&frictionMode)!=0;
180 }
181
184 void setContactProcessingThreshold( btScalar contactProcessingThreshold)
185 {
186 m_contactProcessingThreshold = contactProcessingThreshold;
187 }
188 btScalar getContactProcessingThreshold() const
189 {
190 return m_contactProcessingThreshold;
191 }
192
193 SIMD_FORCE_INLINE bool isStaticObject() const {
194 return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
195 }
196
197 SIMD_FORCE_INLINE bool isKinematicObject() const
198 {
199 return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
200 }
201
202 SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
203 {
204 return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0 ;
205 }
206
207 SIMD_FORCE_INLINE bool hasContactResponse() const {
208 return (m_collisionFlags & CF_NO_CONTACT_RESPONSE)==0;
209 }
210
211
212 btCollisionObject();
213
214 virtual ~btCollisionObject();
215
216 virtual void setCollisionShape(btCollisionShape* collisionShape)
217 {
218 m_updateRevision++;
219 m_collisionShape = collisionShape;
220 m_rootCollisionShape = collisionShape;
221 }
222
223 SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
224 {
225 return m_collisionShape;
226 }
227
228 SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
229 {
230 return m_collisionShape;
231 }
232
233 void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck)
234 {
235 if (ignoreCollisionCheck)
236 {
237 //We don't check for duplicates. Is it ok to leave that up to the user of this API?
238 //int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
239 //if (index == m_objectsWithoutCollisionCheck.size())
240 //{
241 m_objectsWithoutCollisionCheck.push_back(co);
242 //}
243 }
244 else
245 {
246 m_objectsWithoutCollisionCheck.remove(co);
247 }
248 m_checkCollideWith = m_objectsWithoutCollisionCheck.size() > 0;
249 }
250
251 virtual bool checkCollideWithOverride(const btCollisionObject* co) const
252 {
253 int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
254 if (index < m_objectsWithoutCollisionCheck.size())
255 {
256 return false;
257 }
258 return true;
259 }
260
261
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
384 SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle()
385 {
386 return m_broadphaseHandle;
387 }
388
389 SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const
390 {
391 return m_broadphaseHandle;
392 }
393
394 void setBroadphaseHandle(btBroadphaseProxy* handle)
395 {
396 m_broadphaseHandle = handle;
397 }
398
399
400 const btTransform& getInterpolationWorldTransform() const
401 {
402 return m_interpolationWorldTransform;
403 }
404
405 btTransform& getInterpolationWorldTransform()
406 {
407 return m_interpolationWorldTransform;
408 }
409
410 void setInterpolationWorldTransform(const btTransform& trans)
411 {
412 m_updateRevision++;
413 m_interpolationWorldTransform = trans;
414 }
415
416 void setInterpolationLinearVelocity(const btVector3& linvel)
417 {
418 m_updateRevision++;
419 m_interpolationLinearVelocity = linvel;
420 }
421
422 void setInterpolationAngularVelocity(const btVector3& angvel)
423 {
424 m_updateRevision++;
425 m_interpolationAngularVelocity = angvel;
426 }
427
428 const btVector3& getInterpolationLinearVelocity() const
429 {
430 return m_interpolationLinearVelocity;
431 }
432
433 const btVector3& getInterpolationAngularVelocity() const
434 {
435 return m_interpolationAngularVelocity;
436 }
437
438 SIMD_FORCE_INLINE int getIslandTag() const
439 {
440 return m_islandTag1;
441 }
442
443 void setIslandTag(int tag)
444 {
445 m_islandTag1 = tag;
446 }
447
448 SIMD_FORCE_INLINE int getCompanionId() const
449 {
450 return m_companionId;
451 }
452
453 void setCompanionId(int id)
454 {
455 m_companionId = id;
456 }
457
458 SIMD_FORCE_INLINE btScalar getHitFraction() const
459 {
460 return m_hitFraction;
461 }
462
463 void setHitFraction(btScalar hitFraction)
464 {
465 m_hitFraction = hitFraction;
466 }
467
468
469 SIMD_FORCE_INLINE int getCollisionFlags() const
470 {
471 return m_collisionFlags;
472 }
473
474 void setCollisionFlags(int flags)
475 {
476 m_collisionFlags = flags;
477 }
478
480 btScalar getCcdSweptSphereRadius() const
481 {
482 return m_ccdSweptSphereRadius;
483 }
484
486 void setCcdSweptSphereRadius(btScalar radius)
487 {
488 m_ccdSweptSphereRadius = radius;
489 }
490
491 btScalar getCcdMotionThreshold() const
492 {
493 return m_ccdMotionThreshold;
494 }
495
496 btScalar getCcdSquareMotionThreshold() const
497 {
498 return m_ccdMotionThreshold*m_ccdMotionThreshold;
499 }
500
501
502
504 void setCcdMotionThreshold(btScalar ccdMotionThreshold)
505 {
506 m_ccdMotionThreshold = ccdMotionThreshold;
507 }
508
510 void* getUserPointer() const
511 {
512 return m_userObjectPointer;
513 }
514
515 int getUserIndex() const
516 {
517 return m_userIndex;
518 }
519
520 int getUserIndex2() const
521 {
522 return m_userIndex2;
523 }
524
526 void setUserPointer(void* userPointer)
527 {
528 m_userObjectPointer = userPointer;
529 }
530
532 void setUserIndex(int index)
533 {
534 m_userIndex = index;
535 }
536
537 void setUserIndex2(int index)
538 {
539 m_userIndex2 = index;
540 }
541
542 int getUpdateRevisionInternal() const
543 {
544 return m_updateRevision;
545 }
546
547
548 inline bool checkCollideWith(const btCollisionObject* co) const
549 {
550 if (m_checkCollideWith)
551 return checkCollideWithOverride(co);
552
553 return true;
554 }
555
556 virtual int calculateSerializeBufferSize() const;
557
559 virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
560
561 virtual void serializeSingleObject(class btSerializer* serializer) const;
562
563 };
564
566 struct btCollisionObjectDoubleData
567 {
568 void *m_broadphaseHandle;
569 void *m_collisionShape;
570 btCollisionShapeData *m_rootCollisionShape;
571 char *m_name;
572
573 btTransformDoubleData m_worldTransform;
574 btTransformDoubleData m_interpolationWorldTransform;
575 btVector3DoubleData m_interpolationLinearVelocity;
576 btVector3DoubleData m_interpolationAngularVelocity;
577 btVector3DoubleData m_anisotropicFriction;
578 double m_contactProcessingThreshold;
579 double m_deactivationTime;
580 double m_friction;
581 double m_rollingFriction;
582 double m_contactDamping;
583 double m_contactStiffness;
584 double m_restitution;
585 double m_hitFraction;
586 double m_ccdSweptSphereRadius;
587 double m_ccdMotionThreshold;
588
589 int m_hasAnisotropicFriction;
590 int m_collisionFlags;
591 int m_islandTag1;
592 int m_companionId;
593 int m_activationState1;
594 int m_internalType;
595 int m_checkCollideWith;
596
597 char m_padding[4];
598 };
599
601 struct btCollisionObjectFloatData
602 {
603 void *m_broadphaseHandle;
604 void *m_collisionShape;
605 btCollisionShapeData *m_rootCollisionShape;
606 char *m_name;
607
608 btTransformFloatData m_worldTransform;
609 btTransformFloatData m_interpolationWorldTransform;
610 btVector3FloatData m_interpolationLinearVelocity;
611 btVector3FloatData m_interpolationAngularVelocity;
612 btVector3FloatData m_anisotropicFriction;
613 float m_contactProcessingThreshold;
614 float m_deactivationTime;
615 float m_friction;
616 float m_rollingFriction;
617 float m_contactDamping;
618 float m_contactStiffness;
619 float m_restitution;
620 float m_hitFraction;
621 float m_ccdSweptSphereRadius;
622 float m_ccdMotionThreshold;
623
624 int m_hasAnisotropicFriction;
625 int m_collisionFlags;
626 int m_islandTag1;
627 int m_companionId;
628 int m_activationState1;
629 int m_internalType;
630 int m_checkCollideWith;
631 char m_padding[4];
632 };
633
634
635
636 SIMD_FORCE_INLINE int btCollisionObject::calculateSerializeBufferSize() const
637 {
638 return sizeof(btCollisionObjectData);
639 }
640
641
642
643 #endif //BT_COLLISION_OBJECT_H
btCollisionObject::m_companionId
int m_companionId
Definition: btCollisionObject.h:81
btCollisionObjectFloatData::m_worldTransform
btTransformFloatData m_worldTransform
Definition: btCollisionObject.h:608
btCollisionObject::setUserIndex2
void setUserIndex2(int index)
Definition: btCollisionObject.h:537
btCollisionObject::m_userIndex2
int m_userIndex2
Definition: btCollisionObject.h:103
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:601
btCollisionObject::getInterpolationAngularVelocity
const btVector3 & getInterpolationAngularVelocity() const
Definition: btCollisionObject.h:433
btCollisionObject::setContactStiffnessAndDamping
void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
Definition: btCollisionObject.h:336
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:274
btCollisionObject::AnisotropicFrictionFlags
AnisotropicFrictionFlags
Definition: btCollisionObject.h:154
btCollisionObjectDoubleData::m_contactProcessingThreshold
double m_contactProcessingThreshold
Definition: btCollisionObject.h:578
btCollisionObject::getUserIndex2
int getUserIndex2() const
Definition: btCollisionObject.h:520
btCollisionObjectFloatData::m_anisotropicFriction
btVector3FloatData m_anisotropicFriction
Definition: btCollisionObject.h:612
btCollisionObject::getContactDamping
btScalar getContactDamping() const
Definition: btCollisionObject.h:356
btCollisionObject::mergesSimulationIslands
bool mergesSimulationIslands() const
Definition: btCollisionObject.h:161
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:114
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:389
btCollisionObjectFloatData::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:626
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:111
btCollisionObjectFloatData::m_interpolationWorldTransform
btTransformFloatData m_interpolationWorldTransform
Definition: btCollisionObject.h:609
btCollisionObjectFloatData::m_ccdMotionThreshold
float m_ccdMotionThreshold
Definition: btCollisionObject.h:622
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:504
btCollisionObject::getContactStiffness
btScalar getContactStiffness() const
Definition: btCollisionObject.h:351
btCollisionObjectFloatData::m_deactivationTime
float m_deactivationTime
Definition: btCollisionObject.h:614
btCollisionObjectDoubleData::m_ccdSweptSphereRadius
double m_ccdSweptSphereRadius
Definition: btCollisionObject.h:586
btCollisionObject::m_objectsWithoutCollisionCheck
btAlignedObjectArray< const btCollisionObject * > m_objectsWithoutCollisionCheck
Definition: btCollisionObject.h:119
btCollisionObject::m_hitFraction
btScalar m_hitFraction
time of impact calculation
Definition: btCollisionObject.h:108
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:463
btCollisionObjectDoubleData::m_contactStiffness
double m_contactStiffness
Definition: btCollisionObject.h:583
btCollisionObject::m_contactDamping
btScalar m_contactDamping
Definition: btCollisionObject.h:90
btCollisionObject::isKinematicObject
bool isKinematicObject() const
Definition: btCollisionObject.h:197
btCollisionObject::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObject.h:372
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:64
btCollisionObjectDoubleData::m_name
char * m_name
Definition: btCollisionObject.h:571
btCollisionObjectFloatData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:624
btTransform.h
btCollisionObject::getActivationState
int getActivationState() const
Definition: btCollisionObject.h:277
btCollisionObjectDoubleData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:589
btAlignedAllocator.h
btCollisionObjectFloatData::m_restitution
float m_restitution
Definition: btCollisionObject.h:619
btCollisionObjectData
#define btCollisionObjectData
Definition: btCollisionObject.h:41
btCollisionObject::m_spinningFriction
btScalar m_spinningFriction
Definition: btCollisionObject.h:89
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition: btCollisionObject.h:54
btCollisionObjectDoubleData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:590
ISLAND_SLEEPING
#define ISLAND_SLEEPING
Definition: btCollisionObject.h:23
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:202
btCollisionObjectDoubleData::m_anisotropicFriction
btVector3DoubleData m_anisotropicFriction
Definition: btCollisionObject.h:577
btCollisionObject::m_collisionShape
btCollisionShape * m_collisionShape
Definition: btCollisionObject.h:69
btCollisionObjectFloatData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:605
btCollisionObject::setIgnoreCollisionCheck
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
Definition: btCollisionObject.h:233
btCollisionObjectFloatData::m_hitFraction
float m_hitFraction
Definition: btCollisionObject.h:620
btCollisionObjectDoubleData::m_hitFraction
double m_hitFraction
Definition: btCollisionObject.h:585
btCollisionObject::setRestitution
void setRestitution(btScalar rest)
Definition: btCollisionObject.h:299
btCollisionObject::checkCollideWith
bool checkCollideWith(const btCollisionObject *co) const
Definition: btCollisionObject.h:548
btSerializer
Definition: btSerializer.h:68
btCollisionObjectDoubleData::m_interpolationAngularVelocity
btVector3DoubleData m_interpolationAngularVelocity
Definition: btCollisionObject.h:576
btCollisionObjectDoubleData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:570
btCollisionObject::getInterpolationLinearVelocity
const btVector3 & getInterpolationLinearVelocity() const
Definition: btCollisionObject.h:428
btCollisionObject::m_anisotropicFriction
btVector3 m_anisotropicFriction
Definition: btCollisionObject.h:64
btCollisionObject::m_deactivationTime
btScalar m_deactivationTime
Definition: btCollisionObject.h:84
btCollisionObject::setCollisionShape
virtual void setCollisionShape(btCollisionShape *collisionShape)
Definition: btCollisionObject.h:216
btCollisionObjectDoubleData::m_internalType
int m_internalType
Definition: btCollisionObject.h:594
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:566
btCollisionObjectFloatData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:604
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:367
btCollisionObject::m_internalType
int m_internalType
m_internalType is reserved to distinguish Bullet&#39;s btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
Definition: btCollisionObject.h:97
btCollisionObject::getBroadphaseHandle
btBroadphaseProxy * getBroadphaseHandle()
Definition: btCollisionObject.h:384
btCollisionObjectDoubleData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:595
btCollisionObject::getAnisotropicFriction
const btVector3 & getAnisotropicFriction() const
Definition: btCollisionObject.h:167
btCollisionObject::setFriction
void setFriction(btScalar frict)
Definition: btCollisionObject.h:308
btCollisionObject::getCcdSquareMotionThreshold
btScalar getCcdSquareMotionThreshold() const
Definition: btCollisionObject.h:496
btCollisionObject::isStaticObject
bool isStaticObject() const
Definition: btCollisionObject.h:193
btCollisionObject::setCcdSweptSphereRadius
void setCcdSweptSphereRadius(btScalar radius)
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:486
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:327
btCollisionObjectFloatData::m_interpolationLinearVelocity
btVector3FloatData m_interpolationLinearVelocity
Definition: btCollisionObject.h:610
btCollisionObjectFloatData::m_rollingFriction
float m_rollingFriction
Definition: btCollisionObject.h:616
btCollisionObjectArray
btAlignedObjectArray< class btCollisionObject * > btCollisionObjectArray
Definition: btCollisionObject.h:30
btCollisionObjectFloatData::m_ccdSweptSphereRadius
float m_ccdSweptSphereRadius
Definition: btCollisionObject.h:621
btCollisionObject::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:83
btCollisionObject::getRestitution
btScalar getRestitution() const
Definition: btCollisionObject.h:304
btCollisionObject::getInterpolationWorldTransform
btTransform & getInterpolationWorldTransform()
Definition: btCollisionObject.h:405
btCollisionObjectDoubleData::m_friction
double m_friction
Definition: btCollisionObject.h:580
btCollisionObject::getDeactivationTime
btScalar getDeactivationTime() const
Definition: btCollisionObject.h:285
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:526
DISABLE_SIMULATION
#define DISABLE_SIMULATION
Definition: btCollisionObject.h:26
btCollisionObject::hasContactResponse
bool hasContactResponse() const
Definition: btCollisionObject.h:207
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:400
btCollisionObject::setUserIndex
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:532
btCollisionObject::m_extensionPointer
void * m_extensionPointer
m_extensionPointer is used by some internal low-level Bullet extensions.
Definition: btCollisionObject.h:71
btCollisionObjectFloatData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:625
btCollisionObject::m_contactProcessingThreshold
btScalar m_contactProcessingThreshold
Definition: btCollisionObject.h:66
btCollisionObject::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btCollisionObject.h:636
btCollisionObject::setDeactivationTime
void setDeactivationTime(btScalar time)
Definition: btCollisionObject.h:281
btCollisionObject::setWorldTransform
void setWorldTransform(const btTransform &worldTrans)
Definition: btCollisionObject.h:377
btCollisionObject::setCompanionId
void setCompanionId(int id)
Definition: btCollisionObject.h:453
btCollisionObject::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:78
btCollisionObjectDoubleData::m_rollingFriction
double m_rollingFriction
Definition: btCollisionObject.h:581
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:122
btCollisionObject::getRollingFriction
btScalar getRollingFriction() const
Definition: btCollisionObject.h:323
btCollisionObject::getUserIndex
int getUserIndex() const
Definition: btCollisionObject.h:515
btCollisionObject::setInterpolationWorldTransform
void setInterpolationWorldTransform(const btTransform &trans)
Definition: btCollisionObject.h:410
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:469
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:188
btCollisionObjectDoubleData::m_ccdMotionThreshold
double m_ccdMotionThreshold
Definition: btCollisionObject.h:587
btCollisionObject::internalGetExtensionPointer
void * internalGetExtensionPointer() const
Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
Definition: btCollisionObject.h:266
btCollisionObject::setInterpolationAngularVelocity
void setInterpolationAngularVelocity(const btVector3 &angvel)
Definition: btCollisionObject.h:422
btCollisionObject::m_rollingFriction
btScalar m_rollingFriction
Definition: btCollisionObject.h:88
btCollisionObjectFloatData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:630
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:629
btCollisionObject::setAnisotropicFriction
void setAnisotropicFriction(const btVector3 &anisotropicFriction, int frictionMode=CF_ANISOTROPIC_FRICTION)
Definition: btCollisionObject.h:171
btCollisionObjectDoubleData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:568
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:591
btMotionState.h
btCollisionObject::getCcdMotionThreshold
btScalar getCcdMotionThreshold() const
Definition: btCollisionObject.h:491
btCollisionObject::getCollisionShape
btCollisionShape * getCollisionShape()
Definition: btCollisionObject.h:228
btCollisionObjectFloatData::m_companionId
int m_companionId
Definition: btCollisionObject.h:627
btCollisionObject::CollisionObjectTypes
CollisionObjectTypes
Definition: btCollisionObject.h:141
btCollisionObjectFloatData::m_friction
float m_friction
Definition: btCollisionObject.h:615
btCollisionObject::getIslandTag
int getIslandTag() const
Definition: btCollisionObject.h:438
btCollisionObject::setCollisionFlags
void setCollisionFlags(int flags)
Definition: btCollisionObject.h:474
btCollisionObject::setBroadphaseHandle
void setBroadphaseHandle(btBroadphaseProxy *handle)
Definition: btCollisionObject.h:394
btCollisionObject::getSpinningFriction
btScalar getSpinningFriction() const
Definition: btCollisionObject.h:332
btCollisionObjectFloatData::m_name
char * m_name
Definition: btCollisionObject.h:606
btCollisionObject::getHitFraction
btScalar getHitFraction() const
Definition: btCollisionObject.h:458
btCollisionObjectDoubleData::m_companionId
int m_companionId
Definition: btCollisionObject.h:592
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:479
btCollisionObjectDoubleData::m_worldTransform
btTransformDoubleData m_worldTransform
Definition: btCollisionObject.h:573
btCollisionObjectDoubleData::m_interpolationWorldTransform
btTransformDoubleData m_interpolationWorldTransform
Definition: btCollisionObject.h:574
btCollisionObject::m_interpolationAngularVelocity
btVector3 m_interpolationAngularVelocity
Definition: btCollisionObject.h:62
btCollisionObjectFloatData::m_contactProcessingThreshold
float m_contactProcessingThreshold
Definition: btCollisionObject.h:613
btTransformFloatData
for serialization
Definition: btTransform.h:253
btCollisionObject::setIslandTag
void setIslandTag(int tag)
Definition: btCollisionObject.h:443
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:362
btCollisionObject::CollisionFlags
CollisionFlags
Definition: btCollisionObject.h:129
btCollisionObject::setRollingFriction
void setRollingFriction(btScalar frict)
Definition: btCollisionObject.h:318
BT_DECLARE_ALIGNED_ALLOCATOR
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:389
btCollisionObjectDoubleData::m_interpolationLinearVelocity
btVector3DoubleData m_interpolationLinearVelocity
Definition: btCollisionObject.h:575
btCollisionObject::m_checkCollideWith
int m_checkCollideWith
If some object should have elaborate collision filtering by sub-classes.
Definition: btCollisionObject.h:117
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
btCollisionObject::m_contactStiffness
btScalar m_contactStiffness
Definition: btCollisionObject.h:91
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:101
btCollisionObjectFloatData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:603
btCollisionObjectFloatData::m_contactDamping
float m_contactDamping
Definition: btCollisionObject.h:617
btCollisionObject::m_restitution
btScalar m_restitution
Definition: btCollisionObject.h:87
btCollisionObject::setInterpolationLinearVelocity
void setInterpolationLinearVelocity(const btVector3 &linvel)
Definition: btCollisionObject.h:416
btAlignedObjectArray.h
btCollisionObjectDoubleData::m_deactivationTime
double m_deactivationTime
Definition: btCollisionObject.h:579
btCollisionObject::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:80
btCollisionObjectDoubleData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:569
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:294
btVector3FloatData
Definition: btVector3.h:1311
btCollisionObject::hasAnisotropicFriction
bool hasAnisotropicFriction(int frictionMode=CF_ANISOTROPIC_FRICTION) const
Definition: btCollisionObject.h:177
btCollisionObject::m_broadphaseHandle
btBroadphaseProxy * m_broadphaseHandle
Definition: btCollisionObject.h:68
btCollisionObjectDoubleData::m_contactDamping
double m_contactDamping
Definition: btCollisionObject.h:582
btCollisionObjectDoubleData::m_padding
char m_padding[4]
Definition: btCollisionObject.h:597
btCollisionObject::getCcdSweptSphereRadius
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:480
btCollisionObjectDoubleData::m_restitution
double m_restitution
Definition: btCollisionObject.h:584
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:184
btCollisionObject::getFriction
btScalar getFriction() const
Definition: btCollisionObject.h:313
btCollisionObjectFloatData::m_interpolationAngularVelocity
btVector3FloatData m_interpolationAngularVelocity
Definition: btCollisionObject.h:611
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:86
btCollisionObject::getCompanionId
int getCompanionId() const
Definition: btCollisionObject.h:448
btCollisionObjectFloatData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:628
btCollisionObject::checkCollideWithOverride
virtual bool checkCollideWithOverride(const btCollisionObject *co) const
Definition: btCollisionObject.h:251
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:223
btVector3DoubleData
Definition: btVector3.h:1316
btCollisionObject::m_userIndex
int m_userIndex
Definition: btCollisionObject.h:105
btCollisionObject::getUserPointer
void * getUserPointer() const
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:510
btCollisionObject::getUpdateRevisionInternal
int getUpdateRevisionInternal() const
Definition: btCollisionObject.h:542
btCollisionObjectDoubleData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:593
btCollisionObjectFloatData::m_contactStiffness
float m_contactStiffness
Definition: btCollisionObject.h:618