Changeset 8284 for code/branches/kicklib2/src/external/bullet/BulletDynamics/Dynamics/btRigidBody.h

Timestamp:

Apr 21, 2011, 6:58:23 PM (13 years ago)

Author:

rgrieder

Message:

Merged revisions 7978 - 8096 from kicklib to kicklib2.

Location:

code/branches/kicklib2

Files:

• . (modified) (1 prop)
• src/external/bullet/BulletDynamics/Dynamics/btRigidBody.h (modified) (13 diffs)

code/branches/kicklib2/src/external/bullet/BulletDynamics/Dynamics/btRigidBody.h

@@ -29 +29 @@
 extern btScalar gDeactivationTime;
 extern bool gDisableDeactivation;
+
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btRigidBodyData btRigidBodyDoubleData
+#define btRigidBodyDataName     "btRigidBodyDoubleData"
+#else
+#define btRigidBodyData btRigidBodyFloatData
+#define btRigidBodyDataName     "btRigidBodyFloatData"
+#endif //BT_USE_DOUBLE_PRECISION
+
+
+enum    btRigidBodyFlags
+{
+        BT_DISABLE_WORLD_GRAVITY = 1
+};
 
 
@@ -46 +60 @@
         btVector3               m_angularVelocity;
         btScalar                m_inverseMass;
-        btScalar                m_angularFactor;
+        btVector3               m_linearFactor;
 
         btVector3               m_gravity;      
@@ -72 +86 @@
         //keep track of typed constraints referencing this rigid body
         btAlignedObjectArray<btTypedConstraint*> m_constraintRefs;
+
+        int                             m_rigidbodyFlags;
+        
+        int                             m_debugBodyId;
+
+
+protected:
+
+        ATTRIBUTE_ALIGNED64(btVector3           m_deltaLinearVelocity);
+        btVector3               m_deltaAngularVelocity;
+        btVector3               m_angularFactor;
+        btVector3               m_invMass;
+        btVector3               m_pushVelocity;
+        btVector3               m_turnVelocity;
+
 
 public:
@@ -111 +140 @@
                 btScalar                        m_additionalAngularDampingFactor;
 
-                
                 btRigidBodyConstructionInfo(    btScalar mass, btMotionState* motionState, btCollisionShape* collisionShape, const btVector3& localInertia=btVector3(0,0,0)):
                 m_mass(mass),
@@ -161 +189 @@
         static const btRigidBody*       upcast(const btCollisionObject* colObj)
         {
-                if (colObj->getInternalType()==btCollisionObject::CO_RIGID_BODY)
+                if (colObj->getInternalType()&btCollisionObject::CO_RIGID_BODY)
                         return (const btRigidBody*)colObj;
                 return 0;
@@ -167 +195 @@
         static btRigidBody*     upcast(btCollisionObject* colObj)
         {
-                if (colObj->getInternalType()==btCollisionObject::CO_RIGID_BODY)
+                if (colObj->getInternalType()&btCollisionObject::CO_RIGID_BODY)
                         return (btRigidBody*)colObj;
                 return 0;
@@ -220 +248 @@
         void                    setMassProps(btScalar mass, const btVector3& inertia);
         
+        const btVector3& getLinearFactor() const
+        {
+                return m_linearFactor;
+        }
+        void setLinearFactor(const btVector3& linearFactor)
+        {
+                m_linearFactor = linearFactor;
+                m_invMass = m_linearFactor*m_inverseMass;
+        }
         btScalar                getInvMass() const { return m_inverseMass; }
         const btMatrix3x3& getInvInertiaTensorWorld() const { 
@@ -231 +268 @@
         void                    applyCentralForce(const btVector3& force)
         {
-                m_totalForce += force;
+                m_totalForce += force*m_linearFactor;
         }
 
@@ -262 +299 @@
         void    applyTorque(const btVector3& torque)
         {
-                m_totalTorque += torque;
+                m_totalTorque += torque*m_angularFactor;
         }
         
@@ -268 +305 @@
         {
                 applyCentralForce(force);
-                applyTorque(rel_pos.cross(force)*m_angularFactor);
+                applyTorque(rel_pos.cross(force*m_linearFactor));
         }
         
         void applyCentralImpulse(const btVector3& impulse)
         {
-                m_linearVelocity += impulse * m_inverseMass;
+                m_linearVelocity += impulse *m_linearFactor * m_inverseMass;
         }
         
         void applyTorqueImpulse(const btVector3& torque)
         {
-                        m_angularVelocity += m_invInertiaTensorWorld * torque;
+                        m_angularVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
         }
         
@@ -288 +325 @@
                         if (m_angularFactor)
                         {
-                                applyTorqueImpulse(rel_pos.cross(impulse)*m_angularFactor);
+                                applyTorqueImpulse(rel_pos.cross(impulse*m_linearFactor));
                         }
                 }
         }
 
-        //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
-        SIMD_FORCE_INLINE void internalApplyImpulse(const btVector3& linearComponent, const btVector3& angularComponent,btScalar impulseMagnitude)
-        {
-                if (m_inverseMass != btScalar(0.))
-                {
-                        m_linearVelocity += linearComponent*impulseMagnitude;
-                        if (m_angularFactor)
-                        {
-                                m_angularVelocity += angularComponent*impulseMagnitude*m_angularFactor;
-                        }
-                }
-        }
-        
         void clearForces() 
         {
@@ -451 +475 @@
         int     m_frictionSolverType;
 
+        void    setAngularFactor(const btVector3& angFac)
+        {
+                m_angularFactor = angFac;
+        }
+
         void    setAngularFactor(btScalar angFac)
         {
-                m_angularFactor = angFac;
-        }
-        btScalar        getAngularFactor() const
+                m_angularFactor.setValue(angFac,angFac,angFac);
+        }
+        const btVector3&        getAngularFactor() const
         {
                 return m_angularFactor;
@@ -481 +510 @@
         }
 
-        int     m_debugBodyId;
+        void    setFlags(int flags)
+        {
+                m_rigidbodyFlags = flags;
+        }
+
+        int getFlags() const
+        {
+                return m_rigidbodyFlags;
+        }
+
+        const btVector3& getDeltaLinearVelocity() const
+        {
+                return m_deltaLinearVelocity;
+        }
+
+        const btVector3& getDeltaAngularVelocity() const
+        {
+                return m_deltaAngularVelocity;
+        }
+
+        const btVector3& getPushVelocity() const 
+        {
+                return m_pushVelocity;
+        }
+
+        const btVector3& getTurnVelocity() const 
+        {
+                return m_turnVelocity;
+        }
+
+
+        ////////////////////////////////////////////////
+        ///some internal methods, don't use them
+                
+        btVector3& internalGetDeltaLinearVelocity()
+        {
+                return m_deltaLinearVelocity;
+        }
+
+        btVector3& internalGetDeltaAngularVelocity()
+        {
+                return m_deltaAngularVelocity;
+        }
+
+        const btVector3& internalGetAngularFactor() const
+        {
+                return m_angularFactor;
+        }
+
+        const btVector3& internalGetInvMass() const
+        {
+                return m_invMass;
+        }
+        
+        btVector3& internalGetPushVelocity()
+        {
+                return m_pushVelocity;
+        }
+
+        btVector3& internalGetTurnVelocity()
+        {
+                return m_turnVelocity;
+        }
+
+        SIMD_FORCE_INLINE void  internalGetVelocityInLocalPointObsolete(const btVector3& rel_pos, btVector3& velocity ) const
+        {
+                velocity = getLinearVelocity()+m_deltaLinearVelocity + (getAngularVelocity()+m_deltaAngularVelocity).cross(rel_pos);
+        }
+
+        SIMD_FORCE_INLINE void  internalGetAngularVelocity(btVector3& angVel) const
+        {
+                angVel = getAngularVelocity()+m_deltaAngularVelocity;
+        }
+
+
+        //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
+        SIMD_FORCE_INLINE void internalApplyImpulse(const btVector3& linearComponent, const btVector3& angularComponent,const btScalar impulseMagnitude)
+        {
+                if (m_inverseMass)
+                {
+                        m_deltaLinearVelocity += linearComponent*impulseMagnitude;
+                        m_deltaAngularVelocity += angularComponent*(impulseMagnitude*m_angularFactor);
+                }
+        }
+
+        SIMD_FORCE_INLINE void internalApplyPushImpulse(const btVector3& linearComponent, const btVector3& angularComponent,btScalar impulseMagnitude)
+        {
+                if (m_inverseMass)
+                {
+                        m_pushVelocity += linearComponent*impulseMagnitude;
+                        m_turnVelocity += angularComponent*(impulseMagnitude*m_angularFactor);
+                }
+        }
+        
+        void    internalWritebackVelocity()
+        {
+                if (m_inverseMass)
+                {
+                        setLinearVelocity(getLinearVelocity()+ m_deltaLinearVelocity);
+                        setAngularVelocity(getAngularVelocity()+m_deltaAngularVelocity);
+                        //m_deltaLinearVelocity.setZero();
+                        //m_deltaAngularVelocity .setZero();
+                        //m_originalBody->setCompanionId(-1);
+                }
+        }
+
+
+        void    internalWritebackVelocity(btScalar timeStep);
+        
+
+        ///////////////////////////////////////////////
+
+        virtual int     calculateSerializeBufferSize()  const;
+
+        ///fills the dataBuffer and returns the struct name (and 0 on failure)
+        virtual const char*     serialize(void* dataBuffer,  class btSerializer* serializer) const;
+
+        virtual void serializeSingleObject(class btSerializer* serializer) const;
+
 };
 
+//@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct  btRigidBodyFloatData
+{
+        btCollisionObjectFloatData      m_collisionObjectData;
+        btMatrix3x3FloatData            m_invInertiaTensorWorld;
+        btVector3FloatData              m_linearVelocity;
+        btVector3FloatData              m_angularVelocity;
+        btVector3FloatData              m_angularFactor;
+        btVector3FloatData              m_linearFactor;
+        btVector3FloatData              m_gravity;      
+        btVector3FloatData              m_gravity_acceleration;
+        btVector3FloatData              m_invInertiaLocal;
+        btVector3FloatData              m_totalForce;
+        btVector3FloatData              m_totalTorque;
+        float                                   m_inverseMass;
+        float                                   m_linearDamping;
+        float                                   m_angularDamping;
+        float                                   m_additionalDampingFactor;
+        float                                   m_additionalLinearDampingThresholdSqr;
+        float                                   m_additionalAngularDampingThresholdSqr;
+        float                                   m_additionalAngularDampingFactor;
+        float                                   m_linearSleepingThreshold;
+        float                                   m_angularSleepingThreshold;
+        int                                             m_additionalDamping;
+};
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct  btRigidBodyDoubleData
+{
+        btCollisionObjectDoubleData     m_collisionObjectData;
+        btMatrix3x3DoubleData           m_invInertiaTensorWorld;
+        btVector3DoubleData             m_linearVelocity;
+        btVector3DoubleData             m_angularVelocity;
+        btVector3DoubleData             m_angularFactor;
+        btVector3DoubleData             m_linearFactor;
+        btVector3DoubleData             m_gravity;      
+        btVector3DoubleData             m_gravity_acceleration;
+        btVector3DoubleData             m_invInertiaLocal;
+        btVector3DoubleData             m_totalForce;
+        btVector3DoubleData             m_totalTorque;
+        double                                  m_inverseMass;
+        double                                  m_linearDamping;
+        double                                  m_angularDamping;
+        double                                  m_additionalDampingFactor;
+        double                                  m_additionalLinearDampingThresholdSqr;
+        double                                  m_additionalAngularDampingThresholdSqr;
+        double                                  m_additionalAngularDampingFactor;
+        double                                  m_linearSleepingThreshold;
+        double                                  m_angularSleepingThreshold;
+        int                                             m_additionalDamping;
+        char    m_padding[4];
+};
+