dali-physics/third-party/bullet3/src/BulletCollision/CollisionDispatch/btCollisionObject.h

   1 /*
   2 Bullet Continuous Collision Detection and Physics Library
   3 Copyright (c) 2003-2006 Erwin Coumans  https://bulletphysics.org
   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 #define FIXED_BASE_MULTI_BODY 6
  28
  29 struct btBroadphaseProxy;
  30 class btCollisionShape;
  31 struct btCollisionShapeData;
  32 #include "LinearMath/btMotionState.h"
  33 #include "LinearMath/btAlignedAllocator.h"
  34 #include "LinearMath/btAlignedObjectArray.h"
  35
  36 typedef btAlignedObjectArray<class btCollisionObject*> btCollisionObjectArray;
  37
  38 #ifdef BT_USE_DOUBLE_PRECISION
  39 #define btCollisionObjectData btCollisionObjectDoubleData
  40 #define btCollisionObjectDataName "btCollisionObjectDoubleData"
  41 #else
  42 #define btCollisionObjectData btCollisionObjectFloatData
  43 #define btCollisionObjectDataName "btCollisionObjectFloatData"
  44 #endif
  45
  46 /// btCollisionObject can be used to manage collision detection objects.
  47 /// btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy.
  48 /// They can be added to the btCollisionWorld.
  49 ATTRIBUTE_ALIGNED16(class)
  50 btCollisionObject
  51 {
  52 protected:
  53         btTransform m_worldTransform;
  54
  55         ///m_interpolationWorldTransform is used for CCD and interpolation
  56         ///it can be either previous or future (predicted) transform
  57         btTransform m_interpolationWorldTransform;
  58         //those two are experimental: just added for bullet time effect, so you can still apply impulses (directly modifying velocities)
  59         //without destroying the continuous interpolated motion (which uses this interpolation velocities)
  60         btVector3 m_interpolationLinearVelocity;
  61         btVector3 m_interpolationAngularVelocity;
  62
  63         btVector3 m_anisotropicFriction;
  64         int m_hasAnisotropicFriction;
  65         btScalar m_contactProcessingThreshold;
  66
  67         btBroadphaseProxy* m_broadphaseHandle;
  68         btCollisionShape* m_collisionShape;
  69         ///m_extensionPointer is used by some internal low-level Bullet extensions.
  70         void* m_extensionPointer;
  71
  72         ///m_rootCollisionShape is temporarily used to store the original collision shape
  73         ///The m_collisionShape might be temporarily replaced by a child collision shape during collision detection purposes
  74         ///If it is NULL, the m_collisionShape is not temporarily replaced.
  75         btCollisionShape* m_rootCollisionShape;
  76
  77         int m_collisionFlags;
  78
  79         int m_islandTag1;
  80         int m_companionId;
  81         int m_worldArrayIndex;  // index of object in world's collisionObjects array
  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         ///m_internalType is reserved to distinguish Bullet's btCollisionObject, btRigidBody, btSoftBody, btGhostObject etc.
  94         ///do not assign your own m_internalType unless you write a new dynamics object class.
  95         int m_internalType;
  96
  97         ///users can point to their objects, m_userPointer is not used by Bullet, see setUserPointer/getUserPointer
  98
  99         void* m_userObjectPointer;
 100
 101         int m_userIndex2;
 102
 103         int m_userIndex;
 104
 105         int m_userIndex3;
 106
 107         ///time of impact calculation
 108         btScalar m_hitFraction;
 109
 110         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
 111         btScalar m_ccdSweptSphereRadius;
 112
 113         /// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold
 114         btScalar m_ccdMotionThreshold;
 115
 116         /// If some object should have elaborate collision filtering by sub-classes
 117         int m_checkCollideWith;
 118
 119         btAlignedObjectArray<const btCollisionObject*> m_objectsWithoutCollisionCheck;
 120
 121         ///internal update revision number. It will be increased when the object changes. This allows some subsystems to perform lazy evaluation.
 122         int m_updateRevision;
 123
 124         btVector3 m_customDebugColorRGB;
 125
 126 public:
 127         BT_DECLARE_ALIGNED_ALLOCATOR();
 128
 129         enum CollisionFlags
 130         {
 131                 CF_DYNAMIC_OBJECT = 0,
 132                 CF_STATIC_OBJECT = 1,
 133                 CF_KINEMATIC_OBJECT = 2,
 134                 CF_NO_CONTACT_RESPONSE = 4,
 135                 CF_CUSTOM_MATERIAL_CALLBACK = 8,  //this allows per-triangle material (friction/restitution)
 136                 CF_CHARACTER_OBJECT = 16,
 137                 CF_DISABLE_VISUALIZE_OBJECT = 32,          //disable debug drawing
 138                 CF_DISABLE_SPU_COLLISION_PROCESSING = 64,  //disable parallel/SPU processing
 139                 CF_HAS_CONTACT_STIFFNESS_DAMPING = 128,
 140                 CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256,
 141                 CF_HAS_FRICTION_ANCHOR = 512,
 142                 CF_HAS_COLLISION_SOUND_TRIGGER = 1024
 143         };
 144
 145         enum CollisionObjectTypes
 146         {
 147                 CO_COLLISION_OBJECT = 1,
 148                 CO_RIGID_BODY = 2,
 149                 ///CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter
 150                 ///It is useful for collision sensors, explosion objects, character controller etc.
 151                 CO_GHOST_OBJECT = 4,
 152                 CO_SOFT_BODY = 8,
 153                 CO_HF_FLUID = 16,
 154                 CO_USER_TYPE = 32,
 155                 CO_FEATHERSTONE_LINK = 64
 156         };
 157
 158         enum AnisotropicFrictionFlags
 159         {
 160                 CF_ANISOTROPIC_FRICTION_DISABLED = 0,
 161                 CF_ANISOTROPIC_FRICTION = 1,
 162                 CF_ANISOTROPIC_ROLLING_FRICTION = 2
 163         };
 164
 165         SIMD_FORCE_INLINE bool mergesSimulationIslands() const
 166         {
 167                 ///static objects, kinematic and object without contact response don't merge islands
 168                 return ((m_collisionFlags & (CF_STATIC_OBJECT | CF_KINEMATIC_OBJECT | CF_NO_CONTACT_RESPONSE)) == 0);
 169         }
 170
 171         const btVector3& getAnisotropicFriction() const
 172         {
 173                 return m_anisotropicFriction;
 174         }
 175         void setAnisotropicFriction(const btVector3& anisotropicFriction, int frictionMode = CF_ANISOTROPIC_FRICTION)
 176         {
 177                 m_anisotropicFriction = anisotropicFriction;
 178                 bool isUnity = (anisotropicFriction[0] != 1.f) || (anisotropicFriction[1] != 1.f) || (anisotropicFriction[2] != 1.f);
 179                 m_hasAnisotropicFriction = isUnity ? frictionMode : 0;
 180         }
 181         bool hasAnisotropicFriction(int frictionMode = CF_ANISOTROPIC_FRICTION) const
 182         {
 183                 return (m_hasAnisotropicFriction & frictionMode) != 0;
 184         }
 185
 186         ///the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default.
 187         ///Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges
 188         void setContactProcessingThreshold(btScalar contactProcessingThreshold)
 189         {
 190                 m_contactProcessingThreshold = contactProcessingThreshold;
 191         }
 192         btScalar getContactProcessingThreshold() const
 193         {
 194                 return m_contactProcessingThreshold;
 195         }
 196
 197         SIMD_FORCE_INLINE bool isStaticObject() const
 198         {
 199                 return (m_collisionFlags & CF_STATIC_OBJECT) != 0;
 200         }
 201
 202         SIMD_FORCE_INLINE bool isKinematicObject() const
 203         {
 204                 return (m_collisionFlags & CF_KINEMATIC_OBJECT) != 0;
 205         }
 206
 207         SIMD_FORCE_INLINE bool isStaticOrKinematicObject() const
 208         {
 209                 return (m_collisionFlags & (CF_KINEMATIC_OBJECT | CF_STATIC_OBJECT)) != 0;
 210         }
 211
 212         SIMD_FORCE_INLINE bool hasContactResponse() const
 213         {
 214                 return (m_collisionFlags & CF_NO_CONTACT_RESPONSE) == 0;
 215         }
 216
 217         btCollisionObject();
 218
 219         virtual ~btCollisionObject();
 220
 221         virtual void setCollisionShape(btCollisionShape * collisionShape)
 222         {
 223                 m_updateRevision++;
 224                 m_collisionShape = collisionShape;
 225                 m_rootCollisionShape = collisionShape;
 226         }
 227
 228         SIMD_FORCE_INLINE const btCollisionShape* getCollisionShape() const
 229         {
 230                 return m_collisionShape;
 231         }
 232
 233         SIMD_FORCE_INLINE btCollisionShape* getCollisionShape()
 234         {
 235                 return m_collisionShape;
 236         }
 237
 238         void setIgnoreCollisionCheck(const btCollisionObject* co, bool ignoreCollisionCheck)
 239         {
 240                 if (ignoreCollisionCheck)
 241                 {
 242                         //We don't check for duplicates. Is it ok to leave that up to the user of this API?
 243                         //int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
 244                         //if (index == m_objectsWithoutCollisionCheck.size())
 245                         //{
 246                         m_objectsWithoutCollisionCheck.push_back(co);
 247                         //}
 248                 }
 249                 else
 250                 {
 251                         m_objectsWithoutCollisionCheck.remove(co);
 252                 }
 253                 m_checkCollideWith = m_objectsWithoutCollisionCheck.size() > 0;
 254         }
 255
 256         int getNumObjectsWithoutCollision() const
 257         {
 258                 return m_objectsWithoutCollisionCheck.size();
 259         }
 260
 261         const btCollisionObject* getObjectWithoutCollision(int index)
 262         {
 263                 return m_objectsWithoutCollisionCheck[index];
 264         }
 265
 266         virtual bool checkCollideWithOverride(const btCollisionObject* co) const
 267         {
 268                 int index = m_objectsWithoutCollisionCheck.findLinearSearch(co);
 269                 if (index < m_objectsWithoutCollisionCheck.size())
 270                 {
 271                         return false;
 272                 }
 273                 return true;
 274         }
 275
 276         ///Avoid using this internal API call, the extension pointer is used by some Bullet extensions.
 277         ///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead.
 278         void* internalGetExtensionPointer() const
 279         {
 280                 return m_extensionPointer;
 281         }
 282         ///Avoid using this internal API call, the extension pointer is used by some Bullet extensions
 283         ///If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead.
 284         void internalSetExtensionPointer(void* pointer)
 285         {
 286                 m_extensionPointer = pointer;
 287         }
 288
 289         SIMD_FORCE_INLINE int getActivationState() const { return m_activationState1; }
 290
 291         void setActivationState(int newState) const;
 292
 293         void setDeactivationTime(btScalar time)
 294         {
 295                 m_deactivationTime = time;
 296         }
 297         btScalar getDeactivationTime() const
 298         {
 299                 return m_deactivationTime;
 300         }
 301
 302         void forceActivationState(int newState) const;
 303
 304         void activate(bool forceActivation = false) const;
 305
 306         SIMD_FORCE_INLINE bool isActive() const
 307         {
 308                 return ((getActivationState() != FIXED_BASE_MULTI_BODY) && (getActivationState() != ISLAND_SLEEPING) && (getActivationState() != DISABLE_SIMULATION));
 309         }
 310
 311         void setRestitution(btScalar rest)
 312         {
 313                 m_updateRevision++;
 314                 m_restitution = rest;
 315         }
 316         btScalar getRestitution() const
 317         {
 318                 return m_restitution;
 319         }
 320         void setFriction(btScalar frict)
 321         {
 322                 m_updateRevision++;
 323                 m_friction = frict;
 324         }
 325         btScalar getFriction() const
 326         {
 327                 return m_friction;
 328         }
 329
 330         void setRollingFriction(btScalar frict)
 331         {
 332                 m_updateRevision++;
 333                 m_rollingFriction = frict;
 334         }
 335         btScalar getRollingFriction() const
 336         {
 337                 return m_rollingFriction;
 338         }
 339         void setSpinningFriction(btScalar frict)
 340         {
 341                 m_updateRevision++;
 342                 m_spinningFriction = frict;
 343         }
 344         btScalar getSpinningFriction() const
 345         {
 346                 return m_spinningFriction;
 347         }
 348         void setContactStiffnessAndDamping(btScalar stiffness, btScalar damping)
 349         {
 350                 m_updateRevision++;
 351                 m_contactStiffness = stiffness;
 352                 m_contactDamping = damping;
 353
 354                 m_collisionFlags |= CF_HAS_CONTACT_STIFFNESS_DAMPING;
 355
 356                 //avoid divisions by zero...
 357                 if (m_contactStiffness < SIMD_EPSILON)
 358                 {
 359                         m_contactStiffness = SIMD_EPSILON;
 360                 }
 361         }
 362
 363         btScalar getContactStiffness() const
 364         {
 365                 return m_contactStiffness;
 366         }
 367
 368         btScalar getContactDamping() const
 369         {
 370                 return m_contactDamping;
 371         }
 372
 373         ///reserved for Bullet internal usage
 374         int getInternalType() const
 375         {
 376                 return m_internalType;
 377         }
 378
 379         btTransform& getWorldTransform()
 380         {
 381                 return m_worldTransform;
 382         }
 383
 384         const btTransform& getWorldTransform() const
 385         {
 386                 return m_worldTransform;
 387         }
 388
 389         void setWorldTransform(const btTransform& worldTrans)
 390         {
 391                 m_updateRevision++;
 392                 m_worldTransform = worldTrans;
 393         }
 394
 395         SIMD_FORCE_INLINE btBroadphaseProxy* getBroadphaseHandle()
 396         {
 397                 return m_broadphaseHandle;
 398         }
 399
 400         SIMD_FORCE_INLINE const btBroadphaseProxy* getBroadphaseHandle() const
 401         {
 402                 return m_broadphaseHandle;
 403         }
 404
 405         void setBroadphaseHandle(btBroadphaseProxy * handle)
 406         {
 407                 m_broadphaseHandle = handle;
 408         }
 409
 410         const btTransform& getInterpolationWorldTransform() const
 411         {
 412                 return m_interpolationWorldTransform;
 413         }
 414
 415         btTransform& getInterpolationWorldTransform()
 416         {
 417                 return m_interpolationWorldTransform;
 418         }
 419
 420         void setInterpolationWorldTransform(const btTransform& trans)
 421         {
 422                 m_updateRevision++;
 423                 m_interpolationWorldTransform = trans;
 424         }
 425
 426         void setInterpolationLinearVelocity(const btVector3& linvel)
 427         {
 428                 m_updateRevision++;
 429                 m_interpolationLinearVelocity = linvel;
 430         }
 431
 432         void setInterpolationAngularVelocity(const btVector3& angvel)
 433         {
 434                 m_updateRevision++;
 435                 m_interpolationAngularVelocity = angvel;
 436         }
 437
 438         const btVector3& getInterpolationLinearVelocity() const
 439         {
 440                 return m_interpolationLinearVelocity;
 441         }
 442
 443         const btVector3& getInterpolationAngularVelocity() const
 444         {
 445                 return m_interpolationAngularVelocity;
 446         }
 447
 448         SIMD_FORCE_INLINE int getIslandTag() const
 449         {
 450                 return m_islandTag1;
 451         }
 452
 453         void setIslandTag(int tag)
 454         {
 455                 m_islandTag1 = tag;
 456         }
 457
 458         SIMD_FORCE_INLINE int getCompanionId() const
 459         {
 460                 return m_companionId;
 461         }
 462
 463         void setCompanionId(int id)
 464         {
 465                 m_companionId = id;
 466         }
 467
 468         SIMD_FORCE_INLINE int getWorldArrayIndex() const
 469         {
 470                 return m_worldArrayIndex;
 471         }
 472
 473         // only should be called by CollisionWorld
 474         void setWorldArrayIndex(int ix)
 475         {
 476                 m_worldArrayIndex = ix;
 477         }
 478
 479         SIMD_FORCE_INLINE btScalar getHitFraction() const
 480         {
 481                 return m_hitFraction;
 482         }
 483
 484         void setHitFraction(btScalar hitFraction)
 485         {
 486                 m_hitFraction = hitFraction;
 487         }
 488
 489         SIMD_FORCE_INLINE int getCollisionFlags() const
 490         {
 491                 return m_collisionFlags;
 492         }
 493
 494         void setCollisionFlags(int flags)
 495         {
 496                 m_collisionFlags = flags;
 497         }
 498
 499         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
 500         btScalar getCcdSweptSphereRadius() const
 501         {
 502                 return m_ccdSweptSphereRadius;
 503         }
 504
 505         ///Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm::
 506         void setCcdSweptSphereRadius(btScalar radius)
 507         {
 508                 m_ccdSweptSphereRadius = radius;
 509         }
 510
 511         btScalar getCcdMotionThreshold() const
 512         {
 513                 return m_ccdMotionThreshold;
 514         }
 515
 516         btScalar getCcdSquareMotionThreshold() const
 517         {
 518                 return m_ccdMotionThreshold * m_ccdMotionThreshold;
 519         }
 520
 521         /// Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold
 522         void setCcdMotionThreshold(btScalar ccdMotionThreshold)
 523         {
 524                 m_ccdMotionThreshold = ccdMotionThreshold;
 525         }
 526
 527         ///users can point to their objects, userPointer is not used by Bullet
 528         void* getUserPointer() const
 529         {
 530                 return m_userObjectPointer;
 531         }
 532
 533         int getUserIndex() const
 534         {
 535                 return m_userIndex;
 536         }
 537
 538         int getUserIndex2() const
 539         {
 540                 return m_userIndex2;
 541         }
 542
 543         int getUserIndex3() const
 544         {
 545                 return m_userIndex3;
 546         }
 547
 548         ///users can point to their objects, userPointer is not used by Bullet
 549         void setUserPointer(void* userPointer)
 550         {
 551                 m_userObjectPointer = userPointer;
 552         }
 553
 554         ///users can point to their objects, userPointer is not used by Bullet
 555         void setUserIndex(int index)
 556         {
 557                 m_userIndex = index;
 558         }
 559
 560         void setUserIndex2(int index)
 561         {
 562                 m_userIndex2 = index;
 563         }
 564
 565         void setUserIndex3(int index)
 566         {
 567                 m_userIndex3 = index;
 568         }
 569
 570         int getUpdateRevisionInternal() const
 571         {
 572                 return m_updateRevision;
 573         }
 574
 575         void setCustomDebugColor(const btVector3& colorRGB)
 576         {
 577                 m_customDebugColorRGB = colorRGB;
 578                 m_collisionFlags |= CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
 579         }
 580
 581         void removeCustomDebugColor()
 582         {
 583                 m_collisionFlags &= ~CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR;
 584         }
 585
 586         bool getCustomDebugColor(btVector3 & colorRGB) const
 587         {
 588                 bool hasCustomColor = (0 != (m_collisionFlags & CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR));
 589                 if (hasCustomColor)
 590                 {
 591                         colorRGB = m_customDebugColorRGB;
 592                 }
 593                 return hasCustomColor;
 594         }
 595
 596         inline bool checkCollideWith(const btCollisionObject* co) const
 597         {
 598                 if (m_checkCollideWith)
 599                         return checkCollideWithOverride(co);
 600
 601                 return true;
 602         }
 603
 604         virtual int calculateSerializeBufferSize() const;
 605
 606         ///fills the dataBuffer and returns the struct name (and 0 on failure)
 607         virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
 608
 609         virtual void serializeSingleObject(class btSerializer * serializer) const;
 610 };
 611
 612 // clang-format off
 613
 614 ///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
 615 struct  btCollisionObjectDoubleData
 616 {
 617         void                                    *m_broadphaseHandle;
 618         void                                    *m_collisionShape;
 619         btCollisionShapeData    *m_rootCollisionShape;
 620         char                                    *m_name;
 621
 622         btTransformDoubleData   m_worldTransform;
 623         btTransformDoubleData   m_interpolationWorldTransform;
 624         btVector3DoubleData             m_interpolationLinearVelocity;
 625         btVector3DoubleData             m_interpolationAngularVelocity;
 626         btVector3DoubleData             m_anisotropicFriction;
 627         double                                  m_contactProcessingThreshold;
 628         double                                  m_deactivationTime;
 629         double                                  m_friction;
 630         double                                  m_rollingFriction;
 631         double                  m_contactDamping;
 632         double                  m_contactStiffness;
 633         double                                  m_restitution;
 634         double                                  m_hitFraction;
 635         double                                  m_ccdSweptSphereRadius;
 636         double                                  m_ccdMotionThreshold;
 637         int                                             m_hasAnisotropicFriction;
 638         int                                             m_collisionFlags;
 639         int                                             m_islandTag1;
 640         int                                             m_companionId;
 641         int                                             m_activationState1;
 642         int                                             m_internalType;
 643         int                                             m_checkCollideWith;
 644         int                                             m_collisionFilterGroup;
 645         int                                             m_collisionFilterMask;
 646         int                                             m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
 647 };
 648
 649 ///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
 650 struct  btCollisionObjectFloatData
 651 {
 652         void                                    *m_broadphaseHandle;
 653         void                                    *m_collisionShape;
 654         btCollisionShapeData    *m_rootCollisionShape;
 655         char                                    *m_name;
 656
 657         btTransformFloatData    m_worldTransform;
 658         btTransformFloatData    m_interpolationWorldTransform;
 659         btVector3FloatData              m_interpolationLinearVelocity;
 660         btVector3FloatData              m_interpolationAngularVelocity;
 661         btVector3FloatData              m_anisotropicFriction;
 662         float                                   m_contactProcessingThreshold;
 663         float                                   m_deactivationTime;
 664         float                                   m_friction;
 665         float                                   m_rollingFriction;
 666         float                   m_contactDamping;
 667     float                   m_contactStiffness;
 668         float                                   m_restitution;
 669         float                                   m_hitFraction;
 670         float                                   m_ccdSweptSphereRadius;
 671         float                                   m_ccdMotionThreshold;
 672         int                                             m_hasAnisotropicFriction;
 673         int                                             m_collisionFlags;
 674         int                                             m_islandTag1;
 675         int                                             m_companionId;
 676         int                                             m_activationState1;
 677         int                                             m_internalType;
 678         int                                             m_checkCollideWith;
 679         int                                             m_collisionFilterGroup;
 680         int                                             m_collisionFilterMask;
 681         int                                             m_uniqueId;
 682 };
 683 // clang-format on
 684
 685 SIMD_FORCE_INLINE int btCollisionObject::calculateSerializeBufferSize() const
 686 {
 687         return sizeof(btCollisionObjectData);
 688 }
 689
 690 #endif  //BT_COLLISION_OBJECT_H