Changeset 8284 for code/branches/kicklib2/src/external/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.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/ConstraintSolver/btHingeConstraint.h (modified) (8 diffs)

code/branches/kicklib2/src/external/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.h

@@ -25 +25 @@
 class btRigidBody;
 
+#ifdef BT_USE_DOUBLE_PRECISION
+#define btHingeConstraintData   btHingeConstraintDoubleData
+#define btHingeConstraintDataName       "btHingeConstraintDoubleData"
+#else
+#define btHingeConstraintData   btHingeConstraintFloatData
+#define btHingeConstraintDataName       "btHingeConstraintFloatData"
+#endif //BT_USE_DOUBLE_PRECISION
+
+
+enum btHingeFlags
+{
+        BT_HINGE_FLAGS_CFM_STOP = 1,
+        BT_HINGE_FLAGS_ERP_STOP = 2,
+        BT_HINGE_FLAGS_CFM_NORM = 4
+};
+
+
 /// hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
 /// axis defines the orientation of the hinge axis
-class btHingeConstraint : public btTypedConstraint
+ATTRIBUTE_ALIGNED16(class) btHingeConstraint : public btTypedConstraint
 {
 #ifdef IN_PARALLELL_SOLVER
@@ -61 +78 @@
         bool            m_solveLimit;
         bool            m_useSolveConstraintObsolete;
+        bool            m_useOffsetForConstraintFrame;
         bool            m_useReferenceFrameA;
 
+        btScalar        m_accMotorImpulse;
+
+        int                     m_flags;
+        btScalar        m_normalCFM;
+        btScalar        m_stopCFM;
+        btScalar        m_stopERP;
+
         
 public:
 
-        btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, btVector3& axisInA,btVector3& axisInB, bool useReferenceFrameA = false);
-
-        btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,btVector3& axisInA, bool useReferenceFrameA = false);
+        btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB, const btVector3& axisInA,const btVector3& axisInB, bool useReferenceFrameA = false);
+
+        btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,const btVector3& axisInA, bool useReferenceFrameA = false);
         
         btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA = false);
@@ -74 +99 @@
         btHingeConstraint(btRigidBody& rbA,const btTransform& rbAFrame, bool useReferenceFrameA = false);
 
-        btHingeConstraint();
 
         virtual void    buildJacobian();
@@ -80 +104 @@
         virtual void getInfo1 (btConstraintInfo1* info);
 
+        void getInfo1NonVirtual(btConstraintInfo1* info);
+
         virtual void getInfo2 (btConstraintInfo2* info);
-        
-        virtual void    solveConstraintObsolete(btSolverBody& bodyA,btSolverBody& bodyB,btScalar        timeStep);
+
+        void    getInfo2NonVirtual(btConstraintInfo2* info,const btTransform& transA,const btTransform& transB,const btVector3& angVelA,const btVector3& angVelB);
+
+        void    getInfo2Internal(btConstraintInfo2* info,const btTransform& transA,const btTransform& transB,const btVector3& angVelA,const btVector3& angVelB);
+        void    getInfo2InternalUsingFrameOffset(btConstraintInfo2* info,const btTransform& transA,const btTransform& transB,const btVector3& angVelA,const btVector3& angVelB);
+                
 
         void    updateRHS(btScalar      timeStep);
@@ -117 +147 @@
         }
 
+        // extra motor API, including ability to set a target rotation (as opposed to angular velocity)
+        // note: setMotorTarget sets angular velocity under the hood, so you must call it every tick to
+        //       maintain a given angular target.
+        void enableMotor(bool enableMotor)      { m_enableAngularMotor = enableMotor; }
+        void setMaxMotorImpulse(btScalar maxMotorImpulse) { m_maxMotorImpulse = maxMotorImpulse; }
+        void setMotorTarget(const btQuaternion& qAinB, btScalar dt); // qAinB is rotation of body A wrt body B.
+        void setMotorTarget(btScalar targetAngle, btScalar dt);
+
+
         void    setLimit(btScalar low,btScalar high,btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)
         {
-                m_lowerLimit = low;
-                m_upperLimit = high;
+                m_lowerLimit = btNormalizeAngle(low);
+                m_upperLimit = btNormalizeAngle(high);
 
                 m_limitSoftness =  _softness;
@@ -128 +167 @@
         }
 
+        void    setAxis(btVector3& axisInA)
+        {
+                btVector3 rbAxisA1, rbAxisA2;
+                btPlaneSpace1(axisInA, rbAxisA1, rbAxisA2);
+                btVector3 pivotInA = m_rbAFrame.getOrigin();
+//              m_rbAFrame.getOrigin() = pivotInA;
+                m_rbAFrame.getBasis().setValue( rbAxisA1.getX(),rbAxisA2.getX(),axisInA.getX(),
+                                                                                rbAxisA1.getY(),rbAxisA2.getY(),axisInA.getY(),
+                                                                                rbAxisA1.getZ(),rbAxisA2.getZ(),axisInA.getZ() );
+
+                btVector3 axisInB = m_rbA.getCenterOfMassTransform().getBasis() * axisInA;
+
+                btQuaternion rotationArc = shortestArcQuat(axisInA,axisInB);
+                btVector3 rbAxisB1 =  quatRotate(rotationArc,rbAxisA1);
+                btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);
+
+
+                m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(pivotInA);
+                m_rbBFrame.getBasis().setValue( rbAxisB1.getX(),rbAxisB2.getX(),axisInB.getX(),
+                                                                                rbAxisB1.getY(),rbAxisB2.getY(),axisInB.getY(),
+                                                                                rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
+        }
+
         btScalar        getLowerLimit() const
         {
@@ -141 +203 @@
         btScalar getHingeAngle();
 
-        void testLimit();
-
-
-        const btTransform& getAFrame() { return m_rbAFrame; };  
-        const btTransform& getBFrame() { return m_rbBFrame; };
+        btScalar getHingeAngle(const btTransform& transA,const btTransform& transB);
+
+        void testLimit(const btTransform& transA,const btTransform& transB);
+
+
+        const btTransform& getAFrame() const { return m_rbAFrame; };    
+        const btTransform& getBFrame() const { return m_rbBFrame; };
+
+        btTransform& getAFrame() { return m_rbAFrame; };        
+        btTransform& getBFrame() { return m_rbBFrame; };
 
         inline int getSolveLimit()
@@ -173 +240 @@
                 return m_maxMotorImpulse; 
         }
+        // access for UseFrameOffset
+        bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; }
+        void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
+
+
+        ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). 
+        ///If no axis is provided, it uses the default axis for this constraint.
+        virtual void    setParam(int num, btScalar value, int axis = -1);
+        ///return the local value of parameter
+        virtual btScalar getParam(int num, int axis = -1) const;
+
+        virtual int     calculateSerializeBufferSize() const;
+
+        ///fills the dataBuffer and returns the struct name (and 0 on failure)
+        virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
+
 
 };
 
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct  btHingeConstraintDoubleData
+{
+        btTypedConstraintData   m_typeConstraintData;
+        btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
+        btTransformDoubleData m_rbBFrame;
+        int                     m_useReferenceFrameA;
+        int                     m_angularOnly;
+        int                     m_enableAngularMotor;
+        float   m_motorTargetVelocity;
+        float   m_maxMotorImpulse;
+
+        float   m_lowerLimit;
+        float   m_upperLimit;
+        float   m_limitSoftness;
+        float   m_biasFactor;
+        float   m_relaxationFactor;
+
+};
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct  btHingeConstraintFloatData
+{
+        btTypedConstraintData   m_typeConstraintData;
+        btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
+        btTransformFloatData m_rbBFrame;
+        int                     m_useReferenceFrameA;
+        int                     m_angularOnly;
+        
+        int                     m_enableAngularMotor;
+        float   m_motorTargetVelocity;
+        float   m_maxMotorImpulse;
+
+        float   m_lowerLimit;
+        float   m_upperLimit;
+        float   m_limitSoftness;
+        float   m_biasFactor;
+        float   m_relaxationFactor;
+
+};
+
+
+
+SIMD_FORCE_INLINE       int     btHingeConstraint::calculateSerializeBufferSize() const
+{
+        return sizeof(btHingeConstraintData);
+}
+
+        ///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE       const char*     btHingeConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+        btHingeConstraintData* hingeData = (btHingeConstraintData*)dataBuffer;
+        btTypedConstraint::serialize(&hingeData->m_typeConstraintData,serializer);
+
+        m_rbAFrame.serialize(hingeData->m_rbAFrame);
+        m_rbBFrame.serialize(hingeData->m_rbBFrame);
+
+        hingeData->m_angularOnly = m_angularOnly;
+        hingeData->m_enableAngularMotor = m_enableAngularMotor;
+        hingeData->m_maxMotorImpulse = float(m_maxMotorImpulse);
+        hingeData->m_motorTargetVelocity = float(m_motorTargetVelocity);
+        hingeData->m_useReferenceFrameA = m_useReferenceFrameA;
+        
+        hingeData->m_lowerLimit = float(m_lowerLimit);
+        hingeData->m_upperLimit = float(m_upperLimit);
+        hingeData->m_limitSoftness = float(m_limitSoftness);
+        hingeData->m_biasFactor = float(m_biasFactor);
+        hingeData->m_relaxationFactor = float(m_relaxationFactor);
+
+        return btHingeConstraintDataName;
+}
+
 #endif //HINGECONSTRAINT_H