Engine/lib/bullet/src/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h

   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_MANIFOLD_CONTACT_POINT_H
  17 #define BT_MANIFOLD_CONTACT_POINT_H
  18
  19 #include "LinearMath/btVector3.h"
  20 #include "LinearMath/btTransformUtil.h"
  21
  22 #ifdef PFX_USE_FREE_VECTORMATH
  23         #include "physics_effects/base_level/solver/pfx_constraint_row.h"
  24 typedef sce::PhysicsEffects::PfxConstraintRow btConstraintRow;
  25 #else
  26         // Don't change following order of parameters
  27         ATTRIBUTE_ALIGNED16(struct) btConstraintRow {
  28                 btScalar m_normal[3];
  29                 btScalar m_rhs;
  30                 btScalar m_jacDiagInv;
  31                 btScalar m_lowerLimit;
  32                 btScalar m_upperLimit;
  33                 btScalar m_accumImpulse;
  34         };
  35         typedef btConstraintRow PfxConstraintRow;
  36 #endif //PFX_USE_FREE_VECTORMATH
  37
  38 enum btContactPointFlags
  39 {
  40         BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED=1,
  41         BT_CONTACT_FLAG_HAS_CONTACT_CFM=2,
  42         BT_CONTACT_FLAG_HAS_CONTACT_ERP=4,
  43     BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8,
  44 };
  45
  46 /// ManifoldContactPoint collects and maintains persistent contactpoints.
  47 /// used to improve stability and performance of rigidbody dynamics response.
  48 class btManifoldPoint
  49         {
  50                 public:
  51                         btManifoldPoint()
  52                                 :m_userPersistentData(0),
  53                                 m_contactPointFlags(0),
  54                                 m_appliedImpulse(0.f),
  55                 m_appliedImpulseLateral1(0.f),
  56                                 m_appliedImpulseLateral2(0.f),
  57                                 m_contactMotion1(0.f),
  58                                 m_contactMotion2(0.f),
  59                                 m_contactCFM(0.f),
  60                                 m_contactERP(0.f),
  61                                 m_frictionCFM(0.f),
  62                                 m_lifeTime(0)
  63                         {
  64                         }
  65
  66                         btManifoldPoint( const btVector3 &pointA, const btVector3 &pointB,
  67                                         const btVector3 &normal,
  68                                         btScalar distance ) :
  69                                         m_localPointA( pointA ),
  70                                         m_localPointB( pointB ),
  71                                         m_normalWorldOnB( normal ),
  72                                         m_distance1( distance ),
  73                                         m_combinedFriction(btScalar(0.)),
  74                                         m_combinedRollingFriction(btScalar(0.)),
  75                     m_combinedSpinningFriction(btScalar(0.)),
  76                     m_combinedRestitution(btScalar(0.)),
  77                                         m_userPersistentData(0),
  78                                         m_contactPointFlags(0),
  79                                         m_appliedImpulse(0.f),
  80                     m_appliedImpulseLateral1(0.f),
  81                                         m_appliedImpulseLateral2(0.f),
  82                                         m_contactMotion1(0.f),
  83                                         m_contactMotion2(0.f),
  84                                         m_contactCFM(0.f),
  85                                         m_contactERP(0.f),
  86                                         m_frictionCFM(0.f),
  87                                         m_lifeTime(0)
  88                         {
  89
  90                         }
  91
  92
  93
  94                         btVector3 m_localPointA;
  95                         btVector3 m_localPointB;
  96                         btVector3       m_positionWorldOnB;
  97                         ///m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity
  98                         btVector3       m_positionWorldOnA;
  99                         btVector3 m_normalWorldOnB;
 100
 101                         btScalar        m_distance1;
 102                         btScalar        m_combinedFriction;
 103                         btScalar        m_combinedRollingFriction;//torsional friction orthogonal to contact normal, useful to make spheres stop rolling forever
 104             btScalar    m_combinedSpinningFriction;//torsional friction around contact normal, useful for grasping objects
 105             btScalar    m_combinedRestitution;
 106
 107                         //BP mod, store contact triangles.
 108                         int                     m_partId0;
 109                         int                     m_partId1;
 110                         int                     m_index0;
 111                         int                     m_index1;
 112
 113                         mutable void*   m_userPersistentData;
 114                         //bool                  m_lateralFrictionInitialized;
 115                         int                             m_contactPointFlags;
 116
 117                         btScalar                m_appliedImpulse;
 118                         btScalar                m_appliedImpulseLateral1;
 119                         btScalar                m_appliedImpulseLateral2;
 120                         btScalar                m_contactMotion1;
 121                         btScalar                m_contactMotion2;
 122
 123                         union
 124                         {
 125                 btScalar                m_contactCFM;
 126                 btScalar        m_combinedContactStiffness1;
 127                         };
 128
 129                         union
 130                         {
 131                 btScalar                m_contactERP;
 132                 btScalar        m_combinedContactDamping1;
 133                         };
 134
 135                         btScalar                m_frictionCFM;
 136
 137                         int                             m_lifeTime;//lifetime of the contactpoint in frames
 138
 139                         btVector3               m_lateralFrictionDir1;
 140                         btVector3               m_lateralFrictionDir2;
 141
 142
 143
 144
 145                         btScalar getDistance() const
 146                         {
 147                                 return m_distance1;
 148                         }
 149                         int     getLifeTime() const
 150                         {
 151                                 return m_lifeTime;
 152                         }
 153
 154                         const btVector3& getPositionWorldOnA() const {
 155                                 return m_positionWorldOnA;
 156 //                              return m_positionWorldOnB + m_normalWorldOnB * m_distance1;
 157                         }
 158
 159                         const btVector3& getPositionWorldOnB() const
 160                         {
 161                                 return m_positionWorldOnB;
 162                         }
 163
 164                         void    setDistance(btScalar dist)
 165                         {
 166                                 m_distance1 = dist;
 167                         }
 168
 169                         ///this returns the most recent applied impulse, to satisfy contact constraints by the constraint solver
 170                         btScalar        getAppliedImpulse() const
 171                         {
 172                                 return m_appliedImpulse;
 173                         }
 174
 175
 176
 177         };
 178
 179 #endif //BT_MANIFOLD_CONTACT_POINT_H