Re-enabled upright constraint.

git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/branches/switch_coordinate_system@4968 178a84e3-b1eb-0310-8ba1-8eac791a3b58

src/karts/kart.cpp

@@ -173,6 +173,9 @@ btTransform Kart::getKartHeading(const float customPitch)
 }   // getKartHeading
 
 // ----------------------------------------------------------------------------
+/** Created the physical representation of this kart. Atm it uses the actual
+ *  extention of the kart model to determine the size of the collision body.
+ */
 void Kart::createPhysics()
 {
     // First: Create the chassis of the kart
@@ -632,9 +635,9 @@ void Kart::update(float dt)
     }
 
     // When really on air, free fly, when near ground, try to glide / adjust for landing
-    //if(!isNearGround())
+    if(!isNearGround())
-//FIXME        m_uprightConstraint->setLimit(M_PI);
+        m_uprightConstraint->setLimit(M_PI);
-    //else
+    else
         m_uprightConstraint->setLimit(m_kart_properties->getUprightTolerance());
 
     m_zipper_time_left = m_zipper_time_left>0.0f ? m_zipper_time_left-dt : 0.0f;

src/physics/btUprightConstraint.cpp

@@ -24,6 +24,7 @@ subject to the following restrictions:
 #include "LinearMath/btTransformUtil.h"
 
 #include "karts/kart.hpp"
+
 //!
 //!
 //!
@@ -84,7 +85,7 @@ void btUprightConstraint::solveAngularLimit(
 
     btVector3 motorImp = clippedMotorImpulse * limit->m_axis;
     body0->applyTorqueImpulse(motorImp);
-}
+}   // solveAngularLimit
 
 //!
 //!
@@ -106,9 +107,9 @@ btUprightConstraint::btUprightConstraint(const Kart *kart,
     m_limit[0].m_accumulatedImpulse = 0.0f;
     m_limit[1].m_accumulatedImpulse = 0.0f;
     m_limit[ 0 ].m_axis             = btVector3( 1, 0, 0 );
-      m_limit[ 1 ].m_axis             = btVector3( 0, 0, 1 );
+    m_limit[ 1 ].m_axis             = btVector3( 0, 1, 0 );
     setLimit( SIMD_PI * 0.4f );
-}
+}   // btUprightConstraint
  
 //!
 //!
@@ -117,23 +118,19 @@ btUprightConstraint::btUprightConstraint(const Kart *kart,
 void btUprightConstraint::buildJacobian()
 {
     btTransform worldTransform = m_rbA.getCenterOfMassTransform() * m_frameInA;
-      btVector3   upAxis         = worldTransform.getBasis().getColumn(1);
+    btVector3   upAxis         = worldTransform.getBasis().getColumn(2);
-      m_limit[ 0 ].m_angle       = m_kart->getHPR().getPitch();
+    m_limit[ 0 ].m_angle       = m_kart->getPitch();
     m_limit[ 1 ].m_angle       = m_kart->getHPR().getRoll();
+
     for ( int i = 0; i < 2; i++ )
     {
-          if ( m_limit[ i ].m_angle < -SIMD_PI )
-                m_limit[ i ].m_angle += 2 * SIMD_PI;
-          if ( m_limit[ i ].m_angle > SIMD_PI )
-                m_limit[ i ].m_angle -= 2 * SIMD_PI;
-
         new (&m_jacAng[ i ])      btJacobianEntry(  m_limit[ i ].m_axis,
             m_rbA.getCenterOfMassTransform().getBasis().transpose(),
             m_rbB.getCenterOfMassTransform().getBasis().transpose(),
             m_rbA.getInvInertiaDiagLocal(),
             m_rbB.getInvInertiaDiagLocal());
     }
-}
+}   // buildJacobian
 
 //!
 //!
@@ -150,9 +147,7 @@ void btUprightConstraint::solveConstraint(btScalar    timeStep)
         if(m_disable_time>0.0f) return;
     }
 
-    solveAngularLimit( &m_limit[ 0 ], m_timeStep, 
+    solveAngularLimit( &m_limit[ 0 ], m_timeStep, btScalar(1.) / m_jacAng[ 0 ].getDiagonal(), &m_rbA );
-                       btScalar(1.) / m_jacAng[ 0 ].getDiagonal(), &m_rbA );
+    solveAngularLimit( &m_limit[ 1 ], m_timeStep, btScalar(1.) / m_jacAng[ 1 ].getDiagonal(), &m_rbA );
-    solveAngularLimit( &m_limit[ 1 ], 
+}   // solveConstraint
-                       m_timeStep, btScalar(1.) / m_jacAng[ 1 ].getDiagonal(), &m_rbA );
-}
 

src/physics/btUprightConstraint.hpp

@@ -24,6 +24,10 @@ subject to the following restrictions:
 class btRigidBody;
 class Kart;
 
+
+class btUprightConstraint : public btTypedConstraint
+{
+private:
     class btUprightConstraintLimit
     {
     public:
@@ -33,10 +37,6 @@ public:
         btScalar    m_currentLimitError;
     };
 
-class btUprightConstraint : public btTypedConstraint
-{
-protected:
-
     //! relative_frames
 
     //!@{
@@ -48,6 +48,7 @@ protected:
     btJacobianEntry m_jacAng[ 2 ];//!< angular constraint
     //!@}
 
+    const Kart     *m_kart;
 protected:
 
     //! temporal variables
@@ -61,7 +62,6 @@ protected:
         btScalar    m_hiLimit;
         btScalar    m_loLimit;
         btScalar    m_disable_time;
-    const Kart* m_kart;
 
         btUprightConstraintLimit        m_limit[ 2 ];
 
@@ -88,40 +88,16 @@ public:
     // -PI,+PI                      is the full range
     // 0,0                          is no rotation around x or z
     // -PI*0.2,+PI*0.2      is a nice bit of tilt
-    void setLimit( btScalar range )
+    void setLimit( btScalar range )            { m_loLimit = -range;
-    {
+                                                 m_hiLimit = +range;        }
-        m_loLimit = -range;
-        m_hiLimit = +range;
-    }
-
     // Error correction scaling
     // 0 - 1
-    //
+    void setErp( btScalar erp )                { m_ERP = erp;                }
-    void setErp( btScalar erp )
+    void setBounce( btScalar bounce )          { m_bounce = bounce;          }
-    {
+    void setMaxLimitForce( btScalar force )    { m_maxLimitForce = force;    }
-        m_ERP = erp;
+    void setLimitSoftness( btScalar softness ) { m_limitSoftness = softness; }
-    }
+    void setDamping( btScalar damping )        { m_damping = damping;        }
-    void setBounce( btScalar bounce )
+    void setDisableTime( btScalar t )          { m_disable_time = t;         }
-    {
-        m_bounce = bounce;
-    }
-    void setMaxLimitForce( btScalar force )
-    {
-        m_maxLimitForce = force;
-    }
-    void setLimitSoftness( btScalar softness )
-    {
-        m_limitSoftness = softness;
-    }
-    void setDamping( btScalar damping )
-    {
-        m_damping = damping;
-    }
-    void setDisableTime( btScalar t )
-    {
-        m_disable_time = t;
-    }
-
     virtual void  buildJacobian();
     virtual void  solveConstraint(btScalar  timeStep);
 };