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

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

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;
89
92 int m_internalType;
93
95
96 void* m_userObjectPointer;
97
98 int m_userIndex;
99
101 btScalar m_hitFraction;
102
104 btScalar m_ccdSweptSphereRadius;
105
107 btScalar m_ccdMotionThreshold;
108
110 int m_checkCollideWith;
111
112 btAlignedObjectArray<const btCollisionObject*> m_objectsWithoutCollisionCheck;
113
115 int m_updateRevision;
116
117
118 public:
119
120 BT_DECLARE_ALIGNED_ALLOCATOR();
121
122 enum CollisionFlags
123 {
124 CF_STATIC_OBJECT= 1,
125 CF_KINEMATIC_OBJECT= 2,
126 CF_NO_CONTACT_RESPONSE = 4,
127 CF_CUSTOM_MATERIAL_CALLBACK = 8,//this allows per-triangle material (friction/restitution)
128 CF_CHARACTER_OBJECT = 16,
129 CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing
130 CF_DISABLE_SPU_COLLISION_PROCESSING = 64//disable parallel/SPU processing
131 };
132
133 enum CollisionObjectTypes
134 {
135 CO_COLLISION_OBJECT =1,
136 CO_RIGID_BODY=2,
139 CO_GHOST_OBJECT=4,
140 CO_SOFT_BODY=8,
141 CO_HF_FLUID=16,
142 CO_USER_TYPE=32,
143 CO_FEATHERSTONE_LINK=64
144 };
145
146 enum AnisotropicFrictionFlags
147 {
148 CF_ANISOTROPIC_FRICTION_DISABLED=0,
149 CF_ANISOTROPIC_FRICTION = 1,
150 CF_ANISOTROPIC_ROLLING_FRICTION = 2
151 };
152
153 SIMD_FORCE_INLINE bool mergesSimulationIslands() const
154 {
156 return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE) )==0);
157 }
158
159 const btVector3& getAnisotropicFriction() const
160 {
161 return m_anisotropicFriction;
162 }
163 void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
164 {
165 m_anisotropicFriction = anisotropicFriction;
166 bool isUnity = (anisotropicFriction[0]!=1.f) || (anisotropicFriction[1]!=1.f) || (anisotropicFriction[2]!=1.f);
167 m_hasAnisotropicFriction = isUnity?frictionMode : 0;
168 }
169 bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const
170 {
171 return (m_hasAnisotropicFriction&frictionMode)!=0;
172 }
173
176 void setContactProcessingThreshold( btScalar contactProcessingThreshold)
177 {
178 m_contactProcessingThreshold = contactProcessingThreshold;
179 }
180 btScalar getContactProcessingThreshold() const
181 {
182 return m_contactProcessingThreshold;
183 }
184
185 SIMD_FORCE_INLINE bool isStaticObject() const {
186 return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
187 }
188
189 SIMD_FORCE_INLINE bool isKinematicObject() const
190 {
191 return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
192 }
193
194 SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
195 {
196 return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0 ;
197 }
198
199 SIMD_FORCE_INLINE bool hasContactResponse() const {
200 return (m_collisionFlags & CF_NO_CONTACT_RESPONSE)==0;
201 }
202
203
204 btCollisionObject();
205
206 virtual ~btCollisionObject();
207
208 virtual void setCollisionShape(btCollisionShape* collisionShape)
209 {
210 m_updateRevision++;
211 m_collisionShape = collisionShape;
212 m_rootCollisionShape = collisionShape;
213 }
214
215 SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
216 {
217 return m_collisionShape;
218 }
219
220 SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
221 {
222 return m_collisionShape;
223 }
224
225 void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck)
226 {
227 if (ignoreCollisionCheck)
228 {
229 //We don't check for duplicates. Is it ok to leave that up to the user of this API?
230 //int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
231 //if (index == m_objectsWithoutCollisionCheck.size())
232 //{
233 m_objectsWithoutCollisionCheck.push_back(co);
234 //}
235 }
236 else
237 {
238 m_objectsWithoutCollisionCheck.remove(co);
239 }
240 m_checkCollideWith = m_objectsWithoutCollisionCheck.size() > 0;
241 }
242
243 virtual bool checkCollideWithOverride(const btCollisionObject* co) const
244 {
245 int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
246 if (index < m_objectsWithoutCollisionCheck.size())
247 {
248 return false;
249 }
250 return true;
251 }
252
253
254
255
258 void* internalGetExtensionPointer() const
259 {
260 return m_extensionPointer;
261 }
264 void internalSetExtensionPointer(void* pointer)
265 {
266 m_extensionPointer = pointer;
267 }
268
269 SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1;}
270
271 void setActivationState(int newState) const;
272
273 void setDeactivationTime(btScalar time)
274 {
275 m_deactivationTime = time;
276 }
277 btScalar getDeactivationTime() const
278 {
279 return m_deactivationTime;
280 }
281
282 void forceActivationState(int newState) const;
283
284 void activate(bool forceActivation = false) const;
285
286 SIMD_FORCE_INLINE bool isActive() const
287 {
288 return ((getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
289 }
290
291 void setRestitution(btScalar rest)
292 {
293 m_updateRevision++;
294 m_restitution = rest;
295 }
296 btScalar getRestitution() const
297 {
298 return m_restitution;
299 }
300 void setFriction(btScalar frict)
301 {
302 m_updateRevision++;
303 m_friction = frict;
304 }
305 btScalar getFriction() const
306 {
307 return m_friction;
308 }
309
310 void setRollingFriction(btScalar frict)
311 {
312 m_updateRevision++;
313 m_rollingFriction = frict;
314 }
315 btScalar getRollingFriction() const
316 {
317 return m_rollingFriction;
318 }
319
320
322 int getInternalType() const
323 {
324 return m_internalType;
325 }
326
327 btTransform& getWorldTransform()
328 {
329 return m_worldTransform;
330 }
331
332 const btTransform& getWorldTransform() const
333 {
334 return m_worldTransform;
335 }
336
337 void setWorldTransform(const btTransform& worldTrans)
338 {
339 m_updateRevision++;
340 m_worldTransform = worldTrans;
341 }
342
343
344 SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle()
345 {
346 return m_broadphaseHandle;
347 }
348
349 SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const
350 {
351 return m_broadphaseHandle;
352 }
353
354 void setBroadphaseHandle(btBroadphaseProxy* handle)
355 {
356 m_broadphaseHandle = handle;
357 }
358
359
360 const btTransform& getInterpolationWorldTransform() const
361 {
362 return m_interpolationWorldTransform;
363 }
364
365 btTransform& getInterpolationWorldTransform()
366 {
367 return m_interpolationWorldTransform;
368 }
369
370 void setInterpolationWorldTransform(const btTransform& trans)
371 {
372 m_updateRevision++;
373 m_interpolationWorldTransform = trans;
374 }
375
376 void setInterpolationLinearVelocity(const btVector3& linvel)
377 {
378 m_updateRevision++;
379 m_interpolationLinearVelocity = linvel;
380 }
381
382 void setInterpolationAngularVelocity(const btVector3& angvel)
383 {
384 m_updateRevision++;
385 m_interpolationAngularVelocity = angvel;
386 }
387
388 const btVector3& getInterpolationLinearVelocity() const
389 {
390 return m_interpolationLinearVelocity;
391 }
392
393 const btVector3& getInterpolationAngularVelocity() const
394 {
395 return m_interpolationAngularVelocity;
396 }
397
398 SIMD_FORCE_INLINE int getIslandTag() const
399 {
400 return m_islandTag1;
401 }
402
403 void setIslandTag(int tag)
404 {
405 m_islandTag1 = tag;
406 }
407
408 SIMD_FORCE_INLINE int getCompanionId() const
409 {
410 return m_companionId;
411 }
412
413 void setCompanionId(int id)
414 {
415 m_companionId = id;
416 }
417
418 SIMD_FORCE_INLINE btScalar getHitFraction() const
419 {
420 return m_hitFraction;
421 }
422
423 void setHitFraction(btScalar hitFraction)
424 {
425 m_hitFraction = hitFraction;
426 }
427
428
429 SIMD_FORCE_INLINE int getCollisionFlags() const
430 {
431 return m_collisionFlags;
432 }
433
434 void setCollisionFlags(int flags)
435 {
436 m_collisionFlags = flags;
437 }
438
440 btScalar getCcdSweptSphereRadius() const
441 {
442 return m_ccdSweptSphereRadius;
443 }
444
446 void setCcdSweptSphereRadius(btScalar radius)
447 {
448 m_ccdSweptSphereRadius = radius;
449 }
450
451 btScalar getCcdMotionThreshold() const
452 {
453 return m_ccdMotionThreshold;
454 }
455
456 btScalar getCcdSquareMotionThreshold() const
457 {
458 return m_ccdMotionThreshold*m_ccdMotionThreshold;
459 }
460
461
462
464 void setCcdMotionThreshold(btScalar ccdMotionThreshold)
465 {
466 m_ccdMotionThreshold = ccdMotionThreshold;
467 }
468
470 void* getUserPointer() const
471 {
472 return m_userObjectPointer;
473 }
474
475 int getUserIndex() const
476 {
477 return m_userIndex;
478 }
480 void setUserPointer(void* userPointer)
481 {
482 m_userObjectPointer = userPointer;
483 }
484
486 void setUserIndex(int index)
487 {
488 m_userIndex = index;
489 }
490
491 int getUpdateRevisionInternal() const
492 {
493 return m_updateRevision;
494 }
495
496
497 inline bool checkCollideWith(const btCollisionObject* co) const
498 {
499 if (m_checkCollideWith)
500 return checkCollideWithOverride(co);
501
502 return true;
503 }
504
505 virtual int calculateSerializeBufferSize() const;
506
508 virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
509
510 virtual void serializeSingleObject(class btSerializer* serializer) const;
511
512 };
513
515 struct btCollisionObjectDoubleData
516 {
517 void *m_broadphaseHandle;
518 void *m_collisionShape;
519 btCollisionShapeData *m_rootCollisionShape;
520 char *m_name;
521
522 btTransformDoubleData m_worldTransform;
523 btTransformDoubleData m_interpolationWorldTransform;
524 btVector3DoubleData m_interpolationLinearVelocity;
525 btVector3DoubleData m_interpolationAngularVelocity;
526 btVector3DoubleData m_anisotropicFriction;
527 double m_contactProcessingThreshold;
528 double m_deactivationTime;
529 double m_friction;
530 double m_rollingFriction;
531 double m_restitution;
532 double m_hitFraction;
533 double m_ccdSweptSphereRadius;
534 double m_ccdMotionThreshold;
535
536 int m_hasAnisotropicFriction;
537 int m_collisionFlags;
538 int m_islandTag1;
539 int m_companionId;
540 int m_activationState1;
541 int m_internalType;
542 int m_checkCollideWith;
543
544 char m_padding[4];
545 };
546
548 struct btCollisionObjectFloatData
549 {
550 void *m_broadphaseHandle;
551 void *m_collisionShape;
552 btCollisionShapeData *m_rootCollisionShape;
553 char *m_name;
554
555 btTransformFloatData m_worldTransform;
556 btTransformFloatData m_interpolationWorldTransform;
557 btVector3FloatData m_interpolationLinearVelocity;
558 btVector3FloatData m_interpolationAngularVelocity;
559 btVector3FloatData m_anisotropicFriction;
560 float m_contactProcessingThreshold;
561 float m_deactivationTime;
562 float m_friction;
563 float m_rollingFriction;
564
565 float m_restitution;
566 float m_hitFraction;
567 float m_ccdSweptSphereRadius;
568 float m_ccdMotionThreshold;
569
570 int m_hasAnisotropicFriction;
571 int m_collisionFlags;
572 int m_islandTag1;
573 int m_companionId;
574 int m_activationState1;
575 int m_internalType;
576 int m_checkCollideWith;
577 char m_padding[4];
578 };
579
580
581
582 SIMD_FORCE_INLINE int btCollisionObject::calculateSerializeBufferSize() const
583 {
584 return sizeof(btCollisionObjectData);
585 }
586
587
588
589 #endif //BT_COLLISION_OBJECT_H
btCollisionObject::m_companionId
int m_companionId
Definition: btCollisionObject.h:81
btCollisionObjectFloatData::m_worldTransform
btTransformFloatData m_worldTransform
Definition: btCollisionObject.h:555
btCollisionObject::getUpdateRevisionInternal
int getUpdateRevisionInternal() const
Definition: btCollisionObject.h:491
btCollisionObject::getDeactivationTime
btScalar getDeactivationTime() const
Definition: btCollisionObject.h:277
btCollisionObject::getCcdMotionThreshold
btScalar getCcdMotionThreshold() const
Definition: btCollisionObject.h:451
btCollisionObjectFloatData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btCollisionObject.h:548
btAlignedObjectArray::push_back
void push_back(const T &_Val)
Definition: btAlignedObjectArray.h:268
btCollisionObject::AnisotropicFrictionFlags
AnisotropicFrictionFlags
Definition: btCollisionObject.h:146
btCollisionObject::getCcdSweptSphereRadius
btScalar getCcdSweptSphereRadius() const
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:440
btCollisionObjectDoubleData::m_contactProcessingThreshold
double m_contactProcessingThreshold
Definition: btCollisionObject.h:527
btCollisionObjectFloatData::m_anisotropicFriction
btVector3FloatData m_anisotropicFriction
Definition: btCollisionObject.h:559
btCollisionObject::m_ccdMotionThreshold
btScalar m_ccdMotionThreshold
Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
Definition: btCollisionObject.h:107
btAlignedObjectArray
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
Definition: btAlignedObjectArray.h:47
btCollisionObjectFloatData::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:572
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:104
btCollisionObject::getInternalType
int getInternalType() const
reserved for Bullet internal usage
Definition: btCollisionObject.h:322
btCollisionObject::getInterpolationAngularVelocity
const btVector3 & getInterpolationAngularVelocity() const
Definition: btCollisionObject.h:393
btCollisionObject::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btCollisionObject.h:582
btCollisionObjectFloatData::m_interpolationWorldTransform
btTransformFloatData m_interpolationWorldTransform
Definition: btCollisionObject.h:556
btCollisionObjectFloatData::m_ccdMotionThreshold
float m_ccdMotionThreshold
Definition: btCollisionObject.h:568
btCollisionObject::mergesSimulationIslands
bool mergesSimulationIslands() const
Definition: btCollisionObject.h:153
btCollisionObject::setCcdMotionThreshold
void setCcdMotionThreshold(btScalar ccdMotionThreshold)
Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold...
Definition: btCollisionObject.h:464
btCollisionObjectFloatData::m_deactivationTime
float m_deactivationTime
Definition: btCollisionObject.h:561
btCollisionObjectDoubleData::m_ccdSweptSphereRadius
double m_ccdSweptSphereRadius
Definition: btCollisionObject.h:533
btCollisionObject::m_objectsWithoutCollisionCheck
btAlignedObjectArray< const btCollisionObject * > m_objectsWithoutCollisionCheck
Definition: btCollisionObject.h:112
btCollisionObject::m_hitFraction
btScalar m_hitFraction
time of impact calculation
Definition: btCollisionObject.h:101
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:423
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:63
btCollisionObjectDoubleData::m_name
char * m_name
Definition: btCollisionObject.h:520
btCollisionObjectFloatData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:570
btCollisionObject::getContactProcessingThreshold
btScalar getContactProcessingThreshold() const
Definition: btCollisionObject.h:180
btTransform.h
btCollisionObject::getUserIndex
int getUserIndex() const
Definition: btCollisionObject.h:475
btCollisionObject::getCollisionFlags
int getCollisionFlags() const
Definition: btCollisionObject.h:429
btCollisionObjectDoubleData::m_hasAnisotropicFriction
int m_hasAnisotropicFriction
Definition: btCollisionObject.h:536
btAlignedAllocator.h
btCollisionObjectFloatData::m_restitution
float m_restitution
Definition: btCollisionObject.h:565
btCollisionObjectData
#define btCollisionObjectData
Definition: btCollisionObject.h:41
btCollisionObject::m_worldTransform
btTransform m_worldTransform
Definition: btCollisionObject.h:54
btCollisionObjectDoubleData::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:537
ISLAND_SLEEPING
#define ISLAND_SLEEPING
Definition: btCollisionObject.h:23
btCollisionObjectDoubleData::m_anisotropicFriction
btVector3DoubleData m_anisotropicFriction
Definition: btCollisionObject.h:526
btCollisionObject::getInterpolationLinearVelocity
const btVector3 & getInterpolationLinearVelocity() const
Definition: btCollisionObject.h:388
btCollisionObject::m_collisionShape
btCollisionShape * m_collisionShape
Definition: btCollisionObject.h:69
btCollisionObjectFloatData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:552
btCollisionObject::hasContactResponse
bool hasContactResponse() const
Definition: btCollisionObject.h:199
btCollisionObject::setIgnoreCollisionCheck
void setIgnoreCollisionCheck(const btCollisionObject *co, bool ignoreCollisionCheck)
Definition: btCollisionObject.h:225
btCollisionObjectFloatData::m_hitFraction
float m_hitFraction
Definition: btCollisionObject.h:566
btCollisionObjectDoubleData::m_hitFraction
double m_hitFraction
Definition: btCollisionObject.h:532
btCollisionObject::setRestitution
void setRestitution(btScalar rest)
Definition: btCollisionObject.h:291
btSerializer
Definition: btSerializer.h:68
btCollisionObject::getAnisotropicFriction
const btVector3 & getAnisotropicFriction() const
Definition: btCollisionObject.h:159
btCollisionObjectDoubleData::m_interpolationAngularVelocity
btVector3DoubleData m_interpolationAngularVelocity
Definition: btCollisionObject.h:525
btCollisionObjectDoubleData::m_rootCollisionShape
btCollisionShapeData * m_rootCollisionShape
Definition: btCollisionObject.h:519
btCollisionObject::getCcdSquareMotionThreshold
btScalar getCcdSquareMotionThreshold() const
Definition: btCollisionObject.h:456
btCollisionObject::getInterpolationWorldTransform
const btTransform & getInterpolationWorldTransform() const
Definition: btCollisionObject.h:360
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:208
btCollisionObjectDoubleData::m_internalType
int m_internalType
Definition: btCollisionObject.h:541
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:515
btCollisionObjectFloatData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:551
btCollisionObject::getWorldTransform
btTransform & getWorldTransform()
Definition: btCollisionObject.h:327
btCollisionObject::m_internalType
int m_internalType
m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
Definition: btCollisionObject.h:92
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition: btAlignedObjectArray.h:149
btCollisionObject::getBroadphaseHandle
btBroadphaseProxy * getBroadphaseHandle()
Definition: btCollisionObject.h:344
btCollisionObjectDoubleData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:542
btCollisionObject::getUserPointer
void * getUserPointer() const
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:470
btCollisionObject::setFriction
void setFriction(btScalar frict)
Definition: btCollisionObject.h:300
btCollisionObject::isKinematicObject
bool isKinematicObject() const
Definition: btCollisionObject.h:189
btCollisionObject::isStaticObject
bool isStaticObject() const
Definition: btCollisionObject.h:185
btCollisionObject::setCcdSweptSphereRadius
void setCcdSweptSphereRadius(btScalar radius)
Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
Definition: btCollisionObject.h:446
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
btCollisionObjectFloatData::m_interpolationLinearVelocity
btVector3FloatData m_interpolationLinearVelocity
Definition: btCollisionObject.h:557
btCollisionObjectFloatData::m_rollingFriction
float m_rollingFriction
Definition: btCollisionObject.h:563
btCollisionObjectArray
btAlignedObjectArray< class btCollisionObject * > btCollisionObjectArray
Definition: btCollisionObject.h:30
btCollisionObjectFloatData::m_ccdSweptSphereRadius
float m_ccdSweptSphereRadius
Definition: btCollisionObject.h:567
btCollisionObject::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:83
btCollisionObject::getInterpolationWorldTransform
btTransform & getInterpolationWorldTransform()
Definition: btCollisionObject.h:365
btCollisionObject::isStaticOrKinematicObject
bool isStaticOrKinematicObject() const
Definition: btCollisionObject.h:194
btCollisionObjectDoubleData::m_friction
double m_friction
Definition: btCollisionObject.h:529
btCollisionObject::checkCollideWith
bool checkCollideWith(const btCollisionObject *co) const
Definition: btCollisionObject.h:497
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:480
DISABLE_SIMULATION
#define DISABLE_SIMULATION
Definition: btCollisionObject.h:26
btCollisionObject::setUserIndex
void setUserIndex(int index)
users can point to their objects, userPointer is not used by Bullet
Definition: btCollisionObject.h:486
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:571
btCollisionObject::m_contactProcessingThreshold
btScalar m_contactProcessingThreshold
Definition: btCollisionObject.h:66
btCollisionObject::getRestitution
btScalar getRestitution() const
Definition: btCollisionObject.h:296
btCollisionObjectFloatData::m_padding
char m_padding[4]
Definition: btCollisionObject.h:577
btCollisionObject::setDeactivationTime
void setDeactivationTime(btScalar time)
Definition: btCollisionObject.h:273
btCollisionObject::setWorldTransform
void setWorldTransform(const btTransform &worldTrans)
Definition: btCollisionObject.h:337
btCollisionObject::setCompanionId
void setCompanionId(int id)
Definition: btCollisionObject.h:413
btCollisionObject::m_collisionFlags
int m_collisionFlags
Definition: btCollisionObject.h:78
btCollisionObjectDoubleData::m_rollingFriction
double m_rollingFriction
Definition: btCollisionObject.h:530
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:115
btCollisionObject::setInterpolationWorldTransform
void setInterpolationWorldTransform(const btTransform &trans)
Definition: btCollisionObject.h:370
btBroadphaseProxy
The btBroadphaseProxy is the main class that can be used with the Bullet broadphases.
Definition: btBroadphaseProxy.h:85
btCollisionObject::getHitFraction
btScalar getHitFraction() const
Definition: btCollisionObject.h:418
btCollisionObjectDoubleData::m_ccdMotionThreshold
double m_ccdMotionThreshold
Definition: btCollisionObject.h:534
btCollisionObject::setInterpolationAngularVelocity
void setInterpolationAngularVelocity(const btVector3 &angvel)
Definition: btCollisionObject.h:382
btCollisionObject::m_rollingFriction
btScalar m_rollingFriction
Definition: btCollisionObject.h:88
btCollisionObjectFloatData::m_checkCollideWith
int m_checkCollideWith
Definition: btCollisionObject.h:576
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:64
btCollisionObject::getBroadphaseHandle
const btBroadphaseProxy * getBroadphaseHandle() const
Definition: btCollisionObject.h:349
btCollisionObject::getCompanionId
int getCompanionId() const
Definition: btCollisionObject.h:408
btCollisionObjectFloatData::m_internalType
int m_internalType
Definition: btCollisionObject.h:575
btCollisionObject::setAnisotropicFriction
void setAnisotropicFriction(const btVector3 &anisotropicFriction, int frictionMode=CF_ANISOTROPIC_FRICTION)
Definition: btCollisionObject.h:163
btCollisionObjectDoubleData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:517
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:538
btMotionState.h
btCollisionObject::getCollisionShape
btCollisionShape * getCollisionShape()
Definition: btCollisionObject.h:220
btCollisionObjectFloatData::m_companionId
int m_companionId
Definition: btCollisionObject.h:573
btCollisionObject::CollisionObjectTypes
CollisionObjectTypes
Definition: btCollisionObject.h:133
btCollisionObjectFloatData::m_friction
float m_friction
Definition: btCollisionObject.h:562
btCollisionObject::checkCollideWithOverride
virtual bool checkCollideWithOverride(const btCollisionObject *co) const
Definition: btCollisionObject.h:243
btCollisionObject::setCollisionFlags
void setCollisionFlags(int flags)
Definition: btCollisionObject.h:434
btCollisionObject::getIslandTag
int getIslandTag() const
Definition: btCollisionObject.h:398
btCollisionObject::setBroadphaseHandle
void setBroadphaseHandle(btBroadphaseProxy *handle)
Definition: btCollisionObject.h:354
btCollisionObjectFloatData::m_name
char * m_name
Definition: btCollisionObject.h:553
btCollisionObjectDoubleData::m_companionId
int m_companionId
Definition: btCollisionObject.h:539
btAlignedObjectArray::remove
void remove(const T &key)
Definition: btAlignedObjectArray.h:473
btCollisionObject::hasAnisotropicFriction
bool hasAnisotropicFriction(int frictionMode=CF_ANISOTROPIC_FRICTION) const
Definition: btCollisionObject.h:169
btCollisionObjectDoubleData::m_worldTransform
btTransformDoubleData m_worldTransform
Definition: btCollisionObject.h:522
btCollisionObjectDoubleData::m_interpolationWorldTransform
btTransformDoubleData m_interpolationWorldTransform
Definition: btCollisionObject.h:523
btCollisionObject::m_interpolationAngularVelocity
btVector3 m_interpolationAngularVelocity
Definition: btCollisionObject.h:62
btCollisionObjectFloatData::m_contactProcessingThreshold
float m_contactProcessingThreshold
Definition: btCollisionObject.h:560
btTransformFloatData
for serialization
Definition: btTransform.h:253
btCollisionObject::getRollingFriction
btScalar getRollingFriction() const
Definition: btCollisionObject.h:315
btAlignedObjectArray::findLinearSearch
int findLinearSearch(const T &key) const
Definition: btAlignedObjectArray.h:457
btCollisionObject::setIslandTag
void setIslandTag(int tag)
Definition: btCollisionObject.h:403
btCollisionObject::CollisionFlags
CollisionFlags
Definition: btCollisionObject.h:122
btCollisionObject::setRollingFriction
void setRollingFriction(btScalar frict)
Definition: btCollisionObject.h:310
btCollisionObject::getFriction
btScalar getFriction() const
Definition: btCollisionObject.h:305
btCollisionObject::getWorldTransform
const btTransform & getWorldTransform() const
Definition: btCollisionObject.h:332
BT_DECLARE_ALIGNED_ALLOCATOR
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:388
btCollisionObjectDoubleData::m_interpolationLinearVelocity
btVector3DoubleData m_interpolationLinearVelocity
Definition: btCollisionObject.h:524
btCollisionObject::m_checkCollideWith
int m_checkCollideWith
If some object should have elaborate collision filtering by sub-classes.
Definition: btCollisionObject.h:110
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:264
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:96
btCollisionObjectFloatData::m_broadphaseHandle
void * m_broadphaseHandle
Definition: btCollisionObject.h:550
btCollisionObject::internalGetExtensionPointer
void * internalGetExtensionPointer() const
Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
Definition: btCollisionObject.h:258
btCollisionObject::m_restitution
btScalar m_restitution
Definition: btCollisionObject.h:87
btCollisionObject::setInterpolationLinearVelocity
void setInterpolationLinearVelocity(const btVector3 &linvel)
Definition: btCollisionObject.h:376
btAlignedObjectArray.h
btCollisionObjectDoubleData::m_deactivationTime
double m_deactivationTime
Definition: btCollisionObject.h:528
btCollisionObject::m_islandTag1
int m_islandTag1
Definition: btCollisionObject.h:80
btCollisionObjectDoubleData::m_collisionShape
void * m_collisionShape
Definition: btCollisionObject.h:518
btVector3FloatData
Definition: btVector3.h:1301
btCollisionObject::m_broadphaseHandle
btBroadphaseProxy * m_broadphaseHandle
Definition: btCollisionObject.h:68
btCollisionObjectDoubleData::m_padding
char m_padding[4]
Definition: btCollisionObject.h:544
btCollisionObjectDoubleData::m_restitution
double m_restitution
Definition: btCollisionObject.h:531
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:176
btCollisionObject::getCollisionShape
const btCollisionShape * getCollisionShape() const
Definition: btCollisionObject.h:215
btCollisionObject::getActivationState
int getActivationState() const
Definition: btCollisionObject.h:269
btCollisionObjectFloatData::m_interpolationAngularVelocity
btVector3FloatData m_interpolationAngularVelocity
Definition: btCollisionObject.h:558
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
btCollisionObjectFloatData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:574
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btCollisionObject::isActive
bool isActive() const
Definition: btCollisionObject.h:286
btVector3DoubleData
Definition: btVector3.h:1306
btCollisionObject::m_userIndex
int m_userIndex
Definition: btCollisionObject.h:98
btCollisionObjectDoubleData::m_activationState1
int m_activationState1
Definition: btCollisionObject.h:540