Changeset 8393 for code/trunk/src/external/bullet/BulletDynamics

Timestamp:

May 3, 2011, 5:07:42 AM (14 years ago)

Author:

rgrieder

Message:

Updated Bullet from v2.77 to v2.78.
(I'm not going to make a branch for that since the update from 2.74 to 2.77 hasn't been tested that much either).

You will HAVE to do a complete RECOMPILE! I tested with MSVC and MinGW and they both threw linker errors at me.

Location:

code/trunk/src/external/bullet/BulletDynamics

Files:

• Character/btCharacterControllerInterface.h (modified) (2 diffs)
• Character/btKinematicCharacterController.cpp (modified) (1 diff)
• Character/btKinematicCharacterController.h (modified) (2 diffs)
• ConstraintSolver/btConeTwistConstraint.cpp (modified) (1 diff)
• ConstraintSolver/btConeTwistConstraint.h (modified) (5 diffs)
• ConstraintSolver/btConstraintSolver.h (modified) (2 diffs)
• ConstraintSolver/btContactConstraint.cpp (modified) (2 diffs)
• ConstraintSolver/btContactConstraint.h (modified) (3 diffs)
• ConstraintSolver/btContactSolverInfo.h (modified) (2 diffs)
• ConstraintSolver/btGeneric6DofConstraint.cpp (modified) (2 diffs)
• ConstraintSolver/btGeneric6DofConstraint.h (modified) (7 diffs)
• ConstraintSolver/btGeneric6DofSpringConstraint.cpp (modified) (2 diffs)
• ConstraintSolver/btGeneric6DofSpringConstraint.h (modified) (2 diffs)
• ConstraintSolver/btHinge2Constraint.h (modified) (2 diffs)
• ConstraintSolver/btHingeConstraint.cpp (modified) (22 diffs)
• ConstraintSolver/btHingeConstraint.h (modified) (9 diffs)
• ConstraintSolver/btJacobianEntry.h (modified) (2 diffs)
• ConstraintSolver/btPoint2PointConstraint.h (modified) (2 diffs)
• ConstraintSolver/btSequentialImpulseConstraintSolver.cpp (modified) (13 diffs)
• ConstraintSolver/btSequentialImpulseConstraintSolver.h (modified) (2 diffs)
• ConstraintSolver/btSliderConstraint.h (modified) (4 diffs)
• ConstraintSolver/btSolve2LinearConstraint.h (modified) (2 diffs)
• ConstraintSolver/btTypedConstraint.cpp (modified) (3 diffs)
• ConstraintSolver/btTypedConstraint.h (modified) (4 diffs)
• ConstraintSolver/btUniversalConstraint.cpp (modified) (1 diff)
• ConstraintSolver/btUniversalConstraint.h (modified) (2 diffs)
• Dynamics/btDiscreteDynamicsWorld.cpp (modified) (11 diffs)
• Dynamics/btDiscreteDynamicsWorld.h (modified) (1 diff)
• Dynamics/btDynamicsWorld.h (modified) (2 diffs)
• Dynamics/btRigidBody.cpp (modified) (2 diffs)
• Dynamics/btRigidBody.h (modified) (6 diffs)
• Dynamics/btSimpleDynamicsWorld.cpp (modified) (2 diffs)
• Dynamics/btSimpleDynamicsWorld.h (modified) (1 diff)
• Vehicle/btRaycastVehicle.cpp (modified) (2 diffs)
• Vehicle/btRaycastVehicle.h (modified) (3 diffs)
• Vehicle/btVehicleRaycaster.h (modified) (3 diffs)
• Vehicle/btWheelInfo.h (modified) (2 diffs)

code/trunk/src/external/bullet/BulletDynamics/Character/btCharacterControllerInterface.h

@@ -14 +14 @@
 */
 
-#ifndef CHARACTER_CONTROLLER_INTERFACE_H
-#define CHARACTER_CONTROLLER_INTERFACE_H
+#ifndef BT_CHARACTER_CONTROLLER_INTERFACE_H
+#define BT_CHARACTER_CONTROLLER_INTERFACE_H
 
 #include "LinearMath/btVector3.h"
@@ -43 +43 @@
 };
 
-#endif
+#endif //BT_CHARACTER_CONTROLLER_INTERFACE_H
+

code/trunk/src/external/bullet/BulletDynamics/Character/btKinematicCharacterController.cpp

@@ -85 +85 @@
                 {
                         ///need to transform normal into worldspace
-                        hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
+                        hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
                 }
 

code/trunk/src/external/bullet/BulletDynamics/Character/btKinematicCharacterController.h

@@ -15 +15 @@
 
 
-#ifndef KINEMATIC_CHARACTER_CONTROLLER_H
-#define KINEMATIC_CHARACTER_CONTROLLER_H
+#ifndef BT_KINEMATIC_CHARACTER_CONTROLLER_H
+#define BT_KINEMATIC_CHARACTER_CONTROLLER_H
 
 #include "LinearMath/btVector3.h"
@@ -160 +160 @@
 };
 
-#endif // KINEMATIC_CHARACTER_CONTROLLER_H
+#endif // BT_KINEMATIC_CHARACTER_CONTROLLER_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp

@@ -1115 +1115 @@
 
 
-
+void btConeTwistConstraint::setFrames(const btTransform & frameA, const btTransform & frameB)
+{
+        m_rbAFrame = frameA;
+        m_rbBFrame = frameB;
+        buildJacobian();
+        //calculateTransforms();
+}
+
+ 
+
+

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h

@@ -34 +34 @@
 
 
-#ifndef CONETWISTCONSTRAINT_H
-#define CONETWISTCONSTRAINT_H
+#ifndef BT_CONETWISTCONSTRAINT_H
+#define BT_CONETWISTCONSTRAINT_H
 
 #include "LinearMath/btVector3.h"
@@ -144 +144 @@
 
         void    updateRHS(btScalar      timeStep);
+
 
         const btRigidBody& getRigidBodyA() const
@@ -245 +246 @@
         bool isPastSwingLimit() { return m_solveSwingLimit; }
 
-
         void setDamping(btScalar damping) { m_damping = damping; }
 
@@ -269 +269 @@
         ///If no axis is provided, it uses the default axis for this constraint.
         virtual void setParam(int num, btScalar value, int axis = -1);
+
+        virtual void setFrames(const btTransform& frameA, const btTransform& frameB);
+
+        const btTransform& getFrameOffsetA() const
+        {
+                return m_rbAFrame;
+        }
+
+        const btTransform& getFrameOffsetB() const
+        {
+                return m_rbBFrame;
+        }
+
+
         ///return the local value of parameter
         virtual btScalar getParam(int num, int axis = -1) const;
@@ -330 +344 @@
 
 
-#endif //CONETWISTCONSTRAINT_H
+#endif //BT_CONETWISTCONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btConstraintSolver.h

@@ -14 +14 @@
 */
 
-#ifndef CONSTRAINT_SOLVER_H
-#define CONSTRAINT_SOLVER_H
+#ifndef BT_CONSTRAINT_SOLVER_H
+#define BT_CONSTRAINT_SOLVER_H
 
 #include "LinearMath/btScalar.h"
@@ -50 +50 @@
 
 
-#endif //CONSTRAINT_SOLVER_H
+#endif //BT_CONSTRAINT_SOLVER_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.cpp

@@ -69 +69 @@
 #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"
 
-#define ASSERT2 btAssert
 
-#define USE_INTERNAL_APPLY_IMPULSE 1
+
+//response  between two dynamic objects without friction, assuming 0 penetration depth
+btScalar resolveSingleCollision(
+        btRigidBody* body1,
+        btCollisionObject* colObj2,
+                const btVector3& contactPositionWorld,
+                const btVector3& contactNormalOnB,
+        const btContactSolverInfo& solverInfo,
+                btScalar distance)
+{
+        btRigidBody* body2 = btRigidBody::upcast(colObj2);
+    
+        
+    const btVector3& normal = contactNormalOnB;
+
+    btVector3 rel_pos1 = contactPositionWorld - body1->getWorldTransform().getOrigin(); 
+    btVector3 rel_pos2 = contactPositionWorld - colObj2->getWorldTransform().getOrigin();
+    
+    btVector3 vel1 = body1->getVelocityInLocalPoint(rel_pos1);
+        btVector3 vel2 = body2? body2->getVelocityInLocalPoint(rel_pos2) : btVector3(0,0,0);
+    btVector3 vel = vel1 - vel2;
+    btScalar rel_vel;
+    rel_vel = normal.dot(vel);
+    
+    btScalar combinedRestitution = body1->getRestitution() * colObj2->getRestitution();
+    btScalar restitution = combinedRestitution* -rel_vel;
+
+    btScalar positionalError = solverInfo.m_erp *-distance /solverInfo.m_timeStep ;
+    btScalar velocityError = -(1.0f + restitution) * rel_vel;// * damping;
+        btScalar denom0 = body1->computeImpulseDenominator(contactPositionWorld,normal);
+        btScalar denom1 = body2? body2->computeImpulseDenominator(contactPositionWorld,normal) : 0.f;
+        btScalar relaxation = 1.f;
+        btScalar jacDiagABInv = relaxation/(denom0+denom1);
+
+    btScalar penetrationImpulse = positionalError * jacDiagABInv;
+    btScalar velocityImpulse = velocityError * jacDiagABInv;
+
+    btScalar normalImpulse = penetrationImpulse+velocityImpulse;
+    normalImpulse = 0.f > normalImpulse ? 0.f: normalImpulse;
+
+        body1->applyImpulse(normal*(normalImpulse), rel_pos1);
+    if (body2)
+                body2->applyImpulse(-normal*(normalImpulse), rel_pos2);
+    
+    return normalImpulse;
+}
 
 
@@ -84 +128 @@
 
         btScalar normalLenSqr = normal.length2();
-        ASSERT2(btFabs(normalLenSqr) < btScalar(1.1));
+        btAssert(btFabs(normalLenSqr) < btScalar(1.1));
         if (normalLenSqr > btScalar(1.1))
         {

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.h

@@ -14 +14 @@
 */
 
-#ifndef CONTACT_CONSTRAINT_H
-#define CONTACT_CONSTRAINT_H
+#ifndef BT_CONTACT_CONSTRAINT_H
+#define BT_CONTACT_CONSTRAINT_H
 
 #include "LinearMath/btVector3.h"
@@ -58 +58 @@
 };
 
+///very basic collision resolution without friction
+btScalar resolveSingleCollision(btRigidBody* body1, class btCollisionObject* colObj2, const btVector3& contactPositionWorld,const btVector3& contactNormalOnB, const struct btContactSolverInfo& solverInfo,btScalar distance);
+
 
 ///resolveSingleBilateral is an obsolete methods used for vehicle friction between two dynamic objects
@@ -66 +69 @@
 
 
-#endif //CONTACT_CONSTRAINT_H
+#endif //BT_CONTACT_CONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btContactSolverInfo.h

@@ -14 +14 @@
 */
 
-#ifndef CONTACT_SOLVER_INFO
-#define CONTACT_SOLVER_INFO
+#ifndef BT_CONTACT_SOLVER_INFO
+#define BT_CONTACT_SOLVER_INFO
 
 enum    btSolverMode
@@ -85 +85 @@
 };
 
-#endif //CONTACT_SOLVER_INFO
+#endif //BT_CONTACT_SOLVER_INFO

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp

@@ -711 +711 @@
         (void)timeStep;
 
+}
+
+
+void btGeneric6DofConstraint::setFrames(const btTransform& frameA, const btTransform& frameB)
+{
+        m_frameInA = frameA;
+        m_frameInB = frameB;
+        buildJacobian();
+        calculateTransforms();
 }
 
@@ -1039 +1048 @@
         return retVal;
 }
+
+ 
+
+void btGeneric6DofConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
+{
+        btVector3 zAxis = axis1.normalized();
+        btVector3 yAxis = axis2.normalized();
+        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
+        
+        btTransform frameInW;
+        frameInW.setIdentity();
+        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
+                                        xAxis[1], yAxis[1], zAxis[1],
+                                       xAxis[2], yAxis[2], zAxis[2]);
+        
+        // now get constraint frame in local coordinate systems
+        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
+        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
+        
+        calculateTransforms();
+}

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h

@@ -25 +25 @@
 
 
-#ifndef GENERIC_6DOF_CONSTRAINT_H
-#define GENERIC_6DOF_CONSTRAINT_H
+#ifndef BT_GENERIC_6DOF_CONSTRAINT_H
+#define BT_GENERIC_6DOF_CONSTRAINT_H
 
 #include "LinearMath/btVector3.h"
@@ -434 +434 @@
         btScalar getRelativePivotPosition(int axis_index) const;
 
+        void setFrames(const btTransform & frameA, const btTransform & frameB);
 
         //! Test angular limit.
@@ -447 +448 @@
     }
 
-    void        setLinearUpperLimit(const btVector3& linearUpper)
-    {
-        m_linearLimits.m_upperLimit = linearUpper;
-    }
+        void    getLinearLowerLimit(btVector3& linearLower)
+        {
+                linearLower = m_linearLimits.m_lowerLimit;
+        }
+
+        void    setLinearUpperLimit(const btVector3& linearUpper)
+        {
+                m_linearLimits.m_upperLimit = linearUpper;
+        }
+
+        void    getLinearUpperLimit(btVector3& linearUpper)
+        {
+                linearUpper = m_linearLimits.m_upperLimit;
+        }
 
     void        setAngularLowerLimit(const btVector3& angularLower)
@@ -458 +469 @@
     }
 
+        void    getAngularLowerLimit(btVector3& angularLower)
+        {
+                for(int i = 0; i < 3; i++) 
+                        angularLower[i] = m_angularLimits[i].m_loLimit;
+        }
+
     void        setAngularUpperLimit(const btVector3& angularUpper)
     {
@@ -463 +480 @@
                         m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
     }
+
+        void    getAngularUpperLimit(btVector3& angularUpper)
+        {
+                for(int i = 0; i < 3; i++)
+                        angularUpper[i] = m_angularLimits[i].m_hiLimit;
+        }
 
         //! Retrieves the angular limit informacion
@@ -526 +549 @@
         virtual btScalar getParam(int num, int axis = -1) const;
 
+        void setAxis( const btVector3& axis1, const btVector3& axis2);
+
+
         virtual int     calculateSerializeBufferSize() const;
 
@@ -586 +612 @@
 
 
-#endif //GENERIC_6DOF_CONSTRAINT_H
+#endif //BT_GENERIC_6DOF_CONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp

@@ -22 +22 @@
         : btGeneric6DofConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA)
 {
+        m_objectType = D6_SPRING_CONSTRAINT_TYPE;
+
         for(int i = 0; i < 6; i++)
         {
@@ -148 +150 @@
 
 
+void btGeneric6DofSpringConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
+{
+        btVector3 zAxis = axis1.normalized();
+        btVector3 yAxis = axis2.normalized();
+        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
+
+        btTransform frameInW;
+        frameInW.setIdentity();
+        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
+                                xAxis[1], yAxis[1], zAxis[1],
+                                xAxis[2], yAxis[2], zAxis[2]);
+
+        // now get constraint frame in local coordinate systems
+        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
+        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
+
+  calculateTransforms();
+}
 
 
+

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h

@@ -14 +14 @@
 */
 
-#ifndef GENERIC_6DOF_SPRING_CONSTRAINT_H
-#define GENERIC_6DOF_SPRING_CONSTRAINT_H
+#ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
+#define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
 
 
@@ -49 +49 @@
         void setEquilibriumPoint(int index);  // set the current constraint position/orientation as an equilibrium point for given DOF
         void setEquilibriumPoint(int index, btScalar val);
+
+        virtual void setAxis( const btVector3& axis1, const btVector3& axis2);
+
         virtual void getInfo2 (btConstraintInfo2* info);
+
+        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;
+
 };
 
-#endif // GENERIC_6DOF_SPRING_CONSTRAINT_H
 
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct btGeneric6DofSpringConstraintData
+{
+        btGeneric6DofConstraintData     m_6dofData;
+        
+        int                     m_springEnabled[6];
+        float           m_equilibriumPoint[6];
+        float           m_springStiffness[6];
+        float           m_springDamping[6];
+};
+
+SIMD_FORCE_INLINE       int     btGeneric6DofSpringConstraint::calculateSerializeBufferSize() const
+{
+        return sizeof(btGeneric6DofSpringConstraintData);
+}
+
+        ///fills the dataBuffer and returns the struct name (and 0 on failure)
+SIMD_FORCE_INLINE       const char*     btGeneric6DofSpringConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
+{
+        btGeneric6DofSpringConstraintData* dof = (btGeneric6DofSpringConstraintData*)dataBuffer;
+        btGeneric6DofConstraint::serialize(&dof->m_6dofData,serializer);
+
+        int i;
+        for (i=0;i<6;i++)
+        {
+                dof->m_equilibriumPoint[i] = m_equilibriumPoint[i];
+                dof->m_springDamping[i] = m_springDamping[i];
+                dof->m_springEnabled[i] = m_springEnabled[i]? 1 : 0;
+                dof->m_springStiffness[i] = m_springStiffness[i];
+        }
+        return "btGeneric6DofConstraintData";
+}
+
+#endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
+

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btHinge2Constraint.h

@@ -14 +14 @@
 */
 
-#ifndef HINGE2_CONSTRAINT_H
-#define HINGE2_CONSTRAINT_H
+#ifndef BT_HINGE2_CONSTRAINT_H
+#define BT_HINGE2_CONSTRAINT_H
 
 
@@ -55 +55 @@
 
 
-#endif // HINGE2_CONSTRAINT_H
+#endif // BT_HINGE2_CONSTRAINT_H
 

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp

@@ -44 +44 @@
                                                                          m_useReferenceFrameA(useReferenceFrameA),
                                                                          m_flags(0)
+#ifdef _BT_USE_CENTER_LIMIT_
+                                                                        ,m_limit()
+#endif
 {
         m_rbAFrame.getOrigin() = pivotInA;
@@ -76 +79 @@
                                                                         rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
         
+#ifndef _BT_USE_CENTER_LIMIT_
         //start with free
         m_lowerLimit = btScalar(1.0f);
@@ -83 +87 @@
         m_limitSoftness = 0.9f;
         m_solveLimit = false;
+#endif
         m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
 }
@@ -94 +99 @@
 m_useReferenceFrameA(useReferenceFrameA),
 m_flags(0)
+#ifdef  _BT_USE_CENTER_LIMIT_
+,m_limit()
+#endif
 {
 
@@ -118 +126 @@
                                                                         rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
         
+#ifndef _BT_USE_CENTER_LIMIT_
         //start with free
         m_lowerLimit = btScalar(1.0f);
@@ -125 +134 @@
         m_limitSoftness = 0.9f;
         m_solveLimit = false;
+#endif
         m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
 }
@@ -139 +149 @@
 m_useReferenceFrameA(useReferenceFrameA),
 m_flags(0)
-{
+#ifdef  _BT_USE_CENTER_LIMIT_
+,m_limit()
+#endif
+{
+#ifndef _BT_USE_CENTER_LIMIT_
         //start with free
         m_lowerLimit = btScalar(1.0f);
@@ -147 +161 @@
         m_limitSoftness = 0.9f;
         m_solveLimit = false;
+#endif
         m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
 }                       
@@ -160 +175 @@
 m_useReferenceFrameA(useReferenceFrameA),
 m_flags(0)
+#ifdef  _BT_USE_CENTER_LIMIT_
+,m_limit()
+#endif
 {
         ///not providing rigidbody B means implicitly using worldspace for body B
 
         m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(m_rbAFrame.getOrigin());
-
+#ifndef _BT_USE_CENTER_LIMIT_
         //start with free
         m_lowerLimit = btScalar(1.0f);
@@ -172 +190 @@
         m_limitSoftness = 0.9f;
         m_solveLimit = false;
+#endif
         m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
 }
@@ -450 +469 @@
         if(getSolveLimit())
         {
-                limit_err = m_correction * m_referenceSign;
-                limit = (limit_err > btScalar(0.0)) ? 1 : 2;
+#ifdef  _BT_USE_CENTER_LIMIT_
+        limit_err = m_limit.getCorrection() * m_referenceSign;
+#else
+        limit_err = m_correction * m_referenceSign;
+#endif
+        limit = (limit_err > btScalar(0.0)) ? 1 : 2;
+
         }
         // if the hinge has joint limits or motor, add in the extra row
@@ -515 +539 @@
                         }
                         // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that)
+#ifdef  _BT_USE_CENTER_LIMIT_
+                        btScalar bounce = m_limit.getRelaxationFactor();
+#else
                         btScalar bounce = m_relaxationFactor;
+#endif
                         if(bounce > btScalar(0.0))
                         {
@@ -545 +573 @@
                                 }
                         }
+#ifdef  _BT_USE_CENTER_LIMIT_
+                        info->m_constraintError[srow] *= m_limit.getBiasFactor();
+#else
                         info->m_constraintError[srow] *= m_biasFactor;
+#endif
                 } // if(limit)
         } // if angular limit or powered
@@ -551 +583 @@
 
 
-
-
+void btHingeConstraint::setFrames(const btTransform & frameA, const btTransform & frameB)
+{
+        m_rbAFrame = frameA;
+        m_rbBFrame = frameB;
+        buildJacobian();
+}
 
 
@@ -578 +614 @@
 
 
-#if 0
-void btHingeConstraint::testLimit()
-{
-        // Compute limit information
-        m_hingeAngle = getHingeAngle();  
-        m_correction = btScalar(0.);
-        m_limitSign = btScalar(0.);
-        m_solveLimit = false;
-        if (m_lowerLimit <= m_upperLimit)
-        {
-                if (m_hingeAngle <= m_lowerLimit)
-                {
-                        m_correction = (m_lowerLimit - m_hingeAngle);
-                        m_limitSign = 1.0f;
-                        m_solveLimit = true;
-                } 
-                else if (m_hingeAngle >= m_upperLimit)
-                {
-                        m_correction = m_upperLimit - m_hingeAngle;
-                        m_limitSign = -1.0f;
-                        m_solveLimit = true;
-                }
-        }
-        return;
-}
-#else
-
 
 void btHingeConstraint::testLimit(const btTransform& transA,const btTransform& transB)
@@ -610 +619 @@
         // Compute limit information
         m_hingeAngle = getHingeAngle(transA,transB);
+#ifdef  _BT_USE_CENTER_LIMIT_
+        m_limit.test(m_hingeAngle);
+#else
         m_correction = btScalar(0.);
         m_limitSign = btScalar(0.);
@@ -629 +641 @@
                 }
         }
+#endif
         return;
 }
-#endif
+
 
 static btVector3 vHinge(0, 0, btScalar(1));
@@ -662 +675 @@
 void btHingeConstraint::setMotorTarget(btScalar targetAngle, btScalar dt)
 {
+#ifdef  _BT_USE_CENTER_LIMIT_
+        m_limit.fit(targetAngle);
+#else
         if (m_lowerLimit < m_upperLimit)
         {
@@ -669 +685 @@
                         targetAngle = m_upperLimit;
         }
-
+#endif
         // compute angular velocity
         btScalar curAngle  = getHingeAngle(m_rbA.getCenterOfMassTransform(),m_rbB.getCenterOfMassTransform());
@@ -840 +856 @@
         if(getSolveLimit())
         {
-                limit_err = m_correction * m_referenceSign;
-                limit = (limit_err > btScalar(0.0)) ? 1 : 2;
+#ifdef  _BT_USE_CENTER_LIMIT_
+        limit_err = m_limit.getCorrection() * m_referenceSign;
+#else
+        limit_err = m_correction * m_referenceSign;
+#endif
+        limit = (limit_err > btScalar(0.0)) ? 1 : 2;
+
         }
         // if the hinge has joint limits or motor, add in the extra row
@@ -905 +926 @@
                         }
                         // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that)
+#ifdef  _BT_USE_CENTER_LIMIT_
+                        btScalar bounce = m_limit.getRelaxationFactor();
+#else
                         btScalar bounce = m_relaxationFactor;
+#endif
                         if(bounce > btScalar(0.0))
                         {
@@ -935 +960 @@
                                 }
                         }
+#ifdef  _BT_USE_CENTER_LIMIT_
+                        info->m_constraintError[srow] *= m_limit.getBiasFactor();
+#else
                         info->m_constraintError[srow] *= m_biasFactor;
+#endif
                 } // if(limit)
         } // if angular limit or powered

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.h

@@ -16 +16 @@
 /* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */
 
-#ifndef HINGECONSTRAINT_H
-#define HINGECONSTRAINT_H
+#ifndef BT_HINGECONSTRAINT_H
+#define BT_HINGECONSTRAINT_H
+
+#define _BT_USE_CENTER_LIMIT_ 1
+
 
 #include "LinearMath/btVector3.h"
@@ -32 +35 @@
 #define btHingeConstraintDataName       "btHingeConstraintFloatData"
 #endif //BT_USE_DOUBLE_PRECISION
+
 
 
@@ -58 +62 @@
         btScalar        m_maxMotorImpulse;
 
+
+#ifdef  _BT_USE_CENTER_LIMIT_
+        btAngularLimit  m_limit;
+#else
+        btScalar        m_lowerLimit;   
+        btScalar        m_upperLimit;   
+        btScalar        m_limitSign;
+        btScalar        m_correction;
+
         btScalar        m_limitSoftness; 
         btScalar        m_biasFactor; 
-        btScalar    m_relaxationFactor; 
-
-        btScalar    m_lowerLimit;       
-        btScalar    m_upperLimit;       
-        
+        btScalar        m_relaxationFactor; 
+
+        bool            m_solveLimit;
+#endif
+
         btScalar        m_kHinge;
 
-        btScalar        m_limitSign;
-        btScalar        m_correction;
 
         btScalar        m_accLimitImpulse;
         btScalar        m_hingeAngle;
-        btScalar    m_referenceSign;
+        btScalar        m_referenceSign;
 
         bool            m_angularOnly;
         bool            m_enableAngularMotor;
-        bool            m_solveLimit;
         bool            m_useSolveConstraintObsolete;
         bool            m_useOffsetForConstraintFrame;
@@ -133 +143 @@
         {               
                 return m_rbB;   
-        }       
+        }
+
+        btTransform& getFrameOffsetA()
+        {
+        return m_rbAFrame;
+        }
+
+        btTransform& getFrameOffsetB()
+        {
+                return m_rbBFrame;
+        }
+
+        void setFrames(const btTransform& frameA, const btTransform& frameB);
         
         void    setAngularOnly(bool angularOnly)
@@ -158 +180 @@
         void    setLimit(btScalar low,btScalar high,btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)
         {
+#ifdef  _BT_USE_CENTER_LIMIT_
+                m_limit.set(low, high, _softness, _biasFactor, _relaxationFactor);
+#else
                 m_lowerLimit = btNormalizeAngle(low);
                 m_upperLimit = btNormalizeAngle(high);
-
                 m_limitSoftness =  _softness;
                 m_biasFactor = _biasFactor;
                 m_relaxationFactor = _relaxationFactor;
-
+#endif
         }
 
@@ -183 +207 @@
                 btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);
 
-
-                m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(pivotInA);
+                m_rbBFrame.getOrigin() = m_rbB.getCenterOfMassTransform().inverse()(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() );
+                m_rbBFrame.getBasis() = m_rbB.getCenterOfMassTransform().getBasis().inverse() * m_rbBFrame.getBasis();
+
         }
 
         btScalar        getLowerLimit() const
         {
-                return m_lowerLimit;
+#ifdef  _BT_USE_CENTER_LIMIT_
+        return m_limit.getLow();
+#else
+        return m_lowerLimit;
+#endif
         }
 
         btScalar        getUpperLimit() const
         {
-                return m_upperLimit;
+#ifdef  _BT_USE_CENTER_LIMIT_
+        return m_limit.getHigh();
+#else           
+        return m_upperLimit;
+#endif
         }
 
@@ -216 +250 @@
         inline int getSolveLimit()
         {
-                return m_solveLimit;
+#ifdef  _BT_USE_CENTER_LIMIT_
+        return m_limit.isLimit();
+#else
+        return m_solveLimit;
+#endif
         }
 
         inline btScalar getLimitSign()
         {
+#ifdef  _BT_USE_CENTER_LIMIT_
+        return m_limit.getSign();
+#else
                 return m_limitSign;
+#endif
         }
 
@@ -320 +362 @@
         hingeData->m_motorTargetVelocity = float(m_motorTargetVelocity);
         hingeData->m_useReferenceFrameA = m_useReferenceFrameA;
-        
+#ifdef  _BT_USE_CENTER_LIMIT_
+        hingeData->m_lowerLimit = float(m_limit.getLow());
+        hingeData->m_upperLimit = float(m_limit.getHigh());
+        hingeData->m_limitSoftness = float(m_limit.getSoftness());
+        hingeData->m_biasFactor = float(m_limit.getBiasFactor());
+        hingeData->m_relaxationFactor = float(m_limit.getRelaxationFactor());
+#else
         hingeData->m_lowerLimit = float(m_lowerLimit);
         hingeData->m_upperLimit = float(m_upperLimit);
@@ -326 +374 @@
         hingeData->m_biasFactor = float(m_biasFactor);
         hingeData->m_relaxationFactor = float(m_relaxationFactor);
+#endif
 
         return btHingeConstraintDataName;
 }
 
-#endif //HINGECONSTRAINT_H
+#endif //BT_HINGECONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btJacobianEntry.h

@@ -14 +14 @@
 */
 
-#ifndef JACOBIAN_ENTRY_H
-#define JACOBIAN_ENTRY_H
+#ifndef BT_JACOBIAN_ENTRY_H
+#define BT_JACOBIAN_ENTRY_H
 
 #include "LinearMath/btVector3.h"
@@ -154 +154 @@
 };
 
-#endif //JACOBIAN_ENTRY_H
+#endif //BT_JACOBIAN_ENTRY_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h

@@ -14 +14 @@
 */
 
-#ifndef POINT2POINTCONSTRAINT_H
-#define POINT2POINTCONSTRAINT_H
+#ifndef BT_POINT2POINTCONSTRAINT_H
+#define BT_POINT2POINTCONSTRAINT_H
 
 #include "LinearMath/btVector3.h"
@@ -159 +159 @@
 }
 
-#endif //POINT2POINTCONSTRAINT_H
+#endif //BT_POINT2POINTCONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.cpp

@@ -49 +49 @@
 #ifdef USE_SIMD
 #include <emmintrin.h>
-#define vec_splat(x, e) _mm_shuffle_ps(x, x, _MM_SHUFFLE(e,e,e,e))
-static inline __m128 _vmathVfDot3( __m128 vec0, __m128 vec1 )
+#define btVecSplat(x, e) _mm_shuffle_ps(x, x, _MM_SHUFFLE(e,e,e,e))
+static inline __m128 btSimdDot3( __m128 vec0, __m128 vec1 )
 {
         __m128 result = _mm_mul_ps( vec0, vec1);
-        return _mm_add_ps( vec_splat( result, 0 ), _mm_add_ps( vec_splat( result, 1 ), vec_splat( result, 2 ) ) );
+        return _mm_add_ps( btVecSplat( result, 0 ), _mm_add_ps( btVecSplat( result, 1 ), btVecSplat( result, 2 ) ) );
 }
 #endif//USE_SIMD
@@ -65 +65 @@
         __m128  upperLimit1 = _mm_set1_ps(c.m_upperLimit);
         __m128 deltaImpulse = _mm_sub_ps(_mm_set1_ps(c.m_rhs), _mm_mul_ps(_mm_set1_ps(c.m_appliedImpulse),_mm_set1_ps(c.m_cfm)));
-        __m128 deltaVel1Dotn    =       _mm_add_ps(_vmathVfDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), _vmathVfDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
-        __m128 deltaVel2Dotn    =       _mm_sub_ps(_vmathVfDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),_vmathVfDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
+        __m128 deltaVel1Dotn    =       _mm_add_ps(btSimdDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
+        __m128 deltaVel2Dotn    =       _mm_sub_ps(btSimdDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),btSimdDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
         deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel1Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
         deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel2Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
@@ -128 +128 @@
         __m128  upperLimit1 = _mm_set1_ps(c.m_upperLimit);
         __m128 deltaImpulse = _mm_sub_ps(_mm_set1_ps(c.m_rhs), _mm_mul_ps(_mm_set1_ps(c.m_appliedImpulse),_mm_set1_ps(c.m_cfm)));
-        __m128 deltaVel1Dotn    =       _mm_add_ps(_vmathVfDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), _vmathVfDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
-        __m128 deltaVel2Dotn    =       _mm_sub_ps(_vmathVfDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),_vmathVfDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
+        __m128 deltaVel1Dotn    =       _mm_add_ps(btSimdDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
+        __m128 deltaVel2Dotn    =       _mm_sub_ps(btSimdDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),btSimdDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
         deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel1Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
         deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel2Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
@@ -216 +216 @@
         __m128  upperLimit1 = _mm_set1_ps(c.m_upperLimit);
         __m128 deltaImpulse = _mm_sub_ps(_mm_set1_ps(c.m_rhsPenetration), _mm_mul_ps(_mm_set1_ps(c.m_appliedPushImpulse),_mm_set1_ps(c.m_cfm)));
-        __m128 deltaVel1Dotn    =       _mm_add_ps(_vmathVfDot3(c.m_contactNormal.mVec128,body1.internalGetPushVelocity().mVec128), _vmathVfDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetTurnVelocity().mVec128));
-        __m128 deltaVel2Dotn    =       _mm_sub_ps(_vmathVfDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetTurnVelocity().mVec128),_vmathVfDot3((c.m_contactNormal).mVec128,body2.internalGetPushVelocity().mVec128));
+        __m128 deltaVel1Dotn    =       _mm_add_ps(btSimdDot3(c.m_contactNormal.mVec128,body1.internalGetPushVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetTurnVelocity().mVec128));
+        __m128 deltaVel2Dotn    =       _mm_sub_ps(btSimdDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetTurnVelocity().mVec128),btSimdDot3((c.m_contactNormal).mVec128,body2.internalGetPushVelocity().mVec128));
         deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel1Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
         deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel2Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
@@ -558 +558 @@
 
                                         btScalar positionalError = 0.f;
-                                        positionalError = -penetration * infoGlobal.m_erp/infoGlobal.m_timeStep;
                                         btScalar        velocityError = restitution - rel_vel;// * damping;
+
+                                        if (penetration>0)
+                                        {
+                                                positionalError = 0;
+                                                velocityError -= penetration / infoGlobal.m_timeStep;
+                                        } else
+                                        {
+                                                positionalError = -penetration * infoGlobal.m_erp/infoGlobal.m_timeStep;
+                                        }
+
                                         btScalar  penetrationImpulse = positionalError*solverConstraint.m_jacDiagABInv;
                                         btScalar velocityImpulse = velocityError *solverConstraint.m_jacDiagABInv;
@@ -780 +789 @@
                         btTypedConstraint* constraint = constraints[j];
                         constraint->buildJacobian();
+                        constraint->internalSetAppliedImpulse(0.0f);
                 }
         }
@@ -796 +806 @@
                         {
                                 btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i];
-                                constraints[i]->getInfo1(&info1);
+                                if (constraints[i]->isEnabled())
+                                {
+                                        constraints[i]->getInfo1(&info1);
+                                } else
+                                {
+                                        info1.m_numConstraintRows = 0;
+                                        info1.nub = 0;
+                                }
                                 totalNumRows += info1.m_numConstraintRows;
                         }
@@ -817 +834 @@
 
 
-
                                         btRigidBody& rbA = constraint->getRigidBodyA();
                                         btRigidBody& rbB = constraint->getRigidBodyB();
@@ -826 +842 @@
                                         {
                                                 memset(&currentConstraintRow[j],0,sizeof(btSolverConstraint));
-                                                currentConstraintRow[j].m_lowerLimit = -FLT_MAX;
-                                                currentConstraintRow[j].m_upperLimit = FLT_MAX;
+                                                currentConstraintRow[j].m_lowerLimit = -SIMD_INFINITY;
+                                                currentConstraintRow[j].m_upperLimit = SIMD_INFINITY;
                                                 currentConstraintRow[j].m_appliedImpulse = 0.f;
                                                 currentConstraintRow[j].m_appliedPushImpulse = 0.f;
@@ -860 +876 @@
                                         constraints[i]->getInfo2(&info2);
 
+                                        if (currentConstraintRow->m_upperLimit>constraints[i]->getBreakingImpulseThreshold())
+                                        {
+                                                currentConstraintRow->m_upperLimit = constraints[i]->getBreakingImpulseThreshold();
+                                        }
+
+                                        if (currentConstraintRow->m_lowerLimit<-constraints[i]->getBreakingImpulseThreshold())
+                                        {
+                                                currentConstraintRow->m_lowerLimit = -constraints[i]->getBreakingImpulseThreshold();
+                                        }
+
+
+
                                         ///finalize the constraint setup
                                         for ( j=0;j<info1.m_numConstraintRows;j++)
@@ -1107 +1135 @@
         int iteration;
         {
+                solveGroupCacheFriendlySplitImpulseIterations(bodies ,numBodies,manifoldPtr, numManifolds,constraints,numConstraints,infoGlobal,debugDrawer,stackAlloc);
+
                 for ( iteration = 0;iteration<infoGlobal.m_numIterations;iteration++)
                 {                       
@@ -1112 +1142 @@
                 }
                 
-                solveGroupCacheFriendlySplitImpulseIterations(bodies ,numBodies,manifoldPtr, numManifolds,constraints,numConstraints,infoGlobal,debugDrawer,stackAlloc);
         }
         return 0.f;
@@ -1143 +1172 @@
                 const btSolverConstraint& solverConstr = m_tmpSolverNonContactConstraintPool[j];
                 btTypedConstraint* constr = (btTypedConstraint*)solverConstr.m_originalContactPoint;
-                btScalar sum = constr->internalGetAppliedImpulse();
-                sum += solverConstr.m_appliedImpulse;
-                constr->internalSetAppliedImpulse(sum);
+                constr->internalSetAppliedImpulse(solverConstr.m_appliedImpulse);
+                if (solverConstr.m_appliedImpulse>constr->getBreakingImpulseThreshold())
+                {
+                        constr->setEnabled(false);
+                }
         }
 

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h

@@ -14 +14 @@
 */
 
-#ifndef SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
-#define SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
+#ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
+#define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
 
 #include "btConstraintSolver.h"
@@ -125 +125 @@
 
 
-#endif //SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
+#endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
 

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btSliderConstraint.h

@@ -23 +23 @@
 */
 
-#ifndef SLIDER_CONSTRAINT_H
-#define SLIDER_CONSTRAINT_H
+#ifndef BT_SLIDER_CONSTRAINT_H
+#define BT_SLIDER_CONSTRAINT_H
 
 
@@ -237 +237 @@
         void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
         btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; }
-        btScalar getLinearPos() { return m_linPos; }
+
+        btScalar getLinearPos() const { return m_linPos; }
+        btScalar getAngularPos() const { return m_angPos; }
+        
         
 
@@ -256 +259 @@
         void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
 
+        void setFrames(const btTransform& frameA, const btTransform& frameB) 
+        { 
+                m_frameInA=frameA; 
+                m_frameInB=frameB;
+                calculateTransforms(m_rbA.getCenterOfMassTransform(),m_rbB.getCenterOfMassTransform());
+                buildJacobian();
+        } 
+
+
         ///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.
@@ -318 +330 @@
 
 
-#endif //SLIDER_CONSTRAINT_H
-
+#endif //BT_SLIDER_CONSTRAINT_H
+

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h

@@ -14 +14 @@
 */
 
-#ifndef SOLVE_2LINEAR_CONSTRAINT_H
-#define SOLVE_2LINEAR_CONSTRAINT_H
+#ifndef BT_SOLVE_2LINEAR_CONSTRAINT_H
+#define BT_SOLVE_2LINEAR_CONSTRAINT_H
 
 #include "LinearMath/btMatrix3x3.h"
@@ -105 +105 @@
 };
 
-#endif //SOLVE_2LINEAR_CONSTRAINT_H
+#endif //BT_SOLVE_2LINEAR_CONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.cpp

@@ -30 +30 @@
 m_rbB(getFixedBody()),
 m_appliedImpulse(btScalar(0.)),
-m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE)
+m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE),
+m_breakingImpulseThreshold(SIMD_INFINITY),
+m_isEnabled(true)
 {
 }
@@ -43 +45 @@
 m_rbB(rbB),
 m_appliedImpulse(btScalar(0.)),
-m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE)
+m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE),
+m_breakingImpulseThreshold(SIMD_INFINITY),
+m_isEnabled(true)
 {
 }
@@ -141 +145 @@
 }
 
+
+void btAngularLimit::set(btScalar low, btScalar high, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor)
+{
+        m_halfRange = (high - low) / 2.0f;
+        m_center = btNormalizeAngle(low + m_halfRange);
+        m_softness =  _softness;
+        m_biasFactor = _biasFactor;
+        m_relaxationFactor = _relaxationFactor;
+}
+
+void btAngularLimit::test(const btScalar angle)
+{
+        m_correction = 0.0f;
+        m_sign = 0.0f;
+        m_solveLimit = false;
+
+        if (m_halfRange >= 0.0f)
+        {
+                btScalar deviation = btNormalizeAngle(angle - m_center);
+                if (deviation < -m_halfRange)
+                {
+                        m_solveLimit = true;
+                        m_correction = - (deviation + m_halfRange);
+                        m_sign = +1.0f;
+                }
+                else if (deviation > m_halfRange)
+                {
+                        m_solveLimit = true;
+                        m_correction = m_halfRange - deviation;
+                        m_sign = -1.0f;
+                }
+        }
+}
+
+
+btScalar btAngularLimit::getError() const
+{
+        return m_correction * m_sign;
+}
+
+void btAngularLimit::fit(btScalar& angle) const
+{
+        if (m_halfRange > 0.0f)
+        {
+                btScalar relativeAngle = btNormalizeAngle(angle - m_center);
+                if (!btEqual(relativeAngle, m_halfRange))
+                {
+                        if (relativeAngle > 0.0f)
+                        {
+                                angle = getHigh();
+                        }
+                        else
+                        {
+                                angle = getLow();
+                        }
+                }
+        }
+}
+
+btScalar btAngularLimit::getLow() const
+{
+        return btNormalizeAngle(m_center - m_halfRange);
+}
+
+btScalar btAngularLimit::getHigh() const
+{
+        return btNormalizeAngle(m_center + m_halfRange);
+}

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.h

@@ -14 +14 @@
 */
 
-#ifndef TYPED_CONSTRAINT_H
-#define TYPED_CONSTRAINT_H
+#ifndef BT_TYPED_CONSTRAINT_H
+#define BT_TYPED_CONSTRAINT_H
 
 class btRigidBody;
 #include "LinearMath/btScalar.h"
 #include "btSolverConstraint.h"
-#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
 
 class btSerializer;
 
+//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility
 enum btTypedConstraintType
 {
-        POINT2POINT_CONSTRAINT_TYPE=MAX_CONTACT_MANIFOLD_TYPE+1,
+        POINT2POINT_CONSTRAINT_TYPE=3,
         HINGE_CONSTRAINT_TYPE,
         CONETWIST_CONSTRAINT_TYPE,
         D6_CONSTRAINT_TYPE,
         SLIDER_CONSTRAINT_TYPE,
-        CONTACT_CONSTRAINT_TYPE
+        CONTACT_CONSTRAINT_TYPE,
+        D6_SPRING_CONSTRAINT_TYPE,
+        MAX_CONSTRAINT_TYPE
 };
 
@@ -60 +62 @@
                 void* m_userConstraintPtr;
         };
+
+        btScalar        m_breakingImpulseThreshold;
+        bool            m_isEnabled;
+
 
         bool m_needsFeedback;
@@ -154 +160 @@
         }
 
+
+        btScalar        getBreakingImpulseThreshold() const
+        {
+                return  m_breakingImpulseThreshold;
+        }
+
+        void    setBreakingImpulseThreshold(btScalar threshold)
+        {
+                m_breakingImpulseThreshold = threshold;
+        }
+
+        bool    isEnabled() const
+        {
+                return m_isEnabled;
+        }
+
+        void    setEnabled(bool enabled)
+        {
+                m_isEnabled=enabled;
+        }
+
+
         ///internal method used by the constraint solver, don't use them directly
         virtual void    solveConstraintObsolete(btRigidBody& /*bodyA*/,btRigidBody& /*bodyB*/,btScalar  /*timeStep*/) {};
@@ -312 +340 @@
 
 
-
-#endif //TYPED_CONSTRAINT_H
+class btAngularLimit
+{
+private:
+        btScalar 
+                m_center,
+                m_halfRange,
+                m_softness,
+                m_biasFactor,
+                m_relaxationFactor,
+                m_correction,
+                m_sign;
+
+        bool
+                m_solveLimit;
+
+public:
+        /// Default constructor initializes limit as inactive, allowing free constraint movement
+        btAngularLimit()
+                :m_center(0.0f),
+                m_halfRange(-1.0f),
+                m_softness(0.9f),
+                m_biasFactor(0.3f),
+                m_relaxationFactor(1.0f),
+                m_correction(0.0f),
+                m_sign(0.0f),
+                m_solveLimit(false)
+        {}
+
+        /// Sets all limit's parameters.
+        /// When low > high limit becomes inactive.
+        /// When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit
+        void set(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f);
+
+        /// Checks conastaint angle against limit. If limit is active and the angle violates the limit
+        /// correction is calculated.
+        void test(const btScalar angle);
+
+        /// Returns limit's softness
+        inline btScalar getSoftness() const
+        {
+                return m_softness;
+        }
+
+        /// Returns limit's bias factor
+        inline btScalar getBiasFactor() const
+        {
+                return m_biasFactor;
+        }
+
+        /// Returns limit's relaxation factor
+        inline btScalar getRelaxationFactor() const
+        {
+                return m_relaxationFactor;
+        }
+
+        /// Returns correction value evaluated when test() was invoked 
+        inline btScalar getCorrection() const
+        {
+                return m_correction;
+        }
+
+        /// Returns sign value evaluated when test() was invoked 
+        inline btScalar getSign() const
+        {
+                return m_sign;
+        }
+
+        /// Gives half of the distance between min and max limit angle
+        inline btScalar getHalfRange() const
+        {
+                return m_halfRange;
+        }
+
+        /// Returns true when the last test() invocation recognized limit violation
+        inline bool isLimit() const
+        {
+                return m_solveLimit;
+        }
+
+        /// Checks given angle against limit. If limit is active and angle doesn't fit it, the angle
+        /// returned is modified so it equals to the limit closest to given angle.
+        void fit(btScalar& angle) const;
+
+        /// Returns correction value multiplied by sign value
+        btScalar getError() const;
+
+        btScalar getLow() const;
+
+        btScalar getHigh() const;
+
+};
+
+
+
+#endif //BT_TYPED_CONSTRAINT_H

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btUniversalConstraint.cpp

@@ -62 +62 @@
 }
 
+void btUniversalConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
+{
+  m_axis1 = axis1;
+  m_axis2 = axis2;
+
+        btVector3 zAxis = axis1.normalized();
+        btVector3 yAxis = axis2.normalized();
+        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
+
+        btTransform frameInW;
+        frameInW.setIdentity();
+        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
+                                xAxis[1], yAxis[1], zAxis[1],
+                                xAxis[2], yAxis[2], zAxis[2]);
+        frameInW.setOrigin(m_anchor);
+
+        // now get constraint frame in local coordinate systems
+        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
+        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
+
+  calculateTransforms();
+}
+
+

code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btUniversalConstraint.h

@@ -14 +14 @@
 */
 
-#ifndef UNIVERSAL_CONSTRAINT_H
-#define UNIVERSAL_CONSTRAINT_H
+#ifndef BT_UNIVERSAL_CONSTRAINT_H
+#define BT_UNIVERSAL_CONSTRAINT_H
 
 
@@ -53 +53 @@
         void setUpperLimit(btScalar ang1max, btScalar ang2max) { setAngularUpperLimit(btVector3(0.f, ang1max, ang2max)); }
         void setLowerLimit(btScalar ang1min, btScalar ang2min) { setAngularLowerLimit(btVector3(0.f, ang1min, ang2min)); }
+
+        void setAxis( const btVector3& axis1, const btVector3& axis2);
 };
 
 
 
-#endif // UNIVERSAL_CONSTRAINT_H
+#endif // BT_UNIVERSAL_CONSTRAINT_H
 

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.cpp

@@ -36 +36 @@
 #include "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h"
 #include "BulletDynamics/ConstraintSolver/btSliderConstraint.h"
+#include "BulletDynamics/ConstraintSolver/btContactConstraint.h"
+
 
 #include "LinearMath/btIDebugDraw.h"
@@ -46 +48 @@
 
 #include "LinearMath/btSerializer.h"
+
+#if 0
+btAlignedObjectArray<btVector3> debugContacts;
+btAlignedObjectArray<btVector3> debugNormals;
+int startHit=2;
+int firstHit=startHit;
+#endif
 
 
@@ -315 +324 @@
         dispatchInfo.m_debugDraw = getDebugDrawer();
 
+
         ///perform collision detection
         performDiscreteCollisionDetection();
+
+        if (getDispatchInfo().m_useContinuous)
+                addSpeculativeContacts(timeStep);
+
 
         calculateSimulationIslands();
@@ -746 +760 @@
 class btClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexResultCallback
 {
+public:
+
         btCollisionObject* m_me;
         btScalar m_allowedPenetration;
         btOverlappingPairCache* m_pairCache;
         btDispatcher* m_dispatcher;
-
 
 public:
@@ -798 +813 @@
                 if (m_dispatcher->needsResponse(m_me,otherObj))
                 {
+#if 0
                         ///don't do CCD when there are already contact points (touching contact/penetration)
                         btAlignedObjectArray<btPersistentManifold*> manifoldArray;
@@ -815 +831 @@
                                 }
                         }
-                }
-                return true;
+#endif
+                        return true;
+                }
+
+                return false;
         }
 
@@ -825 +844 @@
 int gNumClampedCcdMotions=0;
 
-//#include "stdio.h"
 void    btDiscreteDynamicsWorld::integrateTransforms(btScalar timeStep)
 {
@@ -837 +855 @@
                 if (body->isActive() && (!body->isStaticOrKinematicObject()))
                 {
+
+                        body->predictIntegratedTransform(timeStep, predictedTrans);
+                        
+                        btScalar squareMotion = (predictedTrans.getOrigin()-body->getWorldTransform().getOrigin()).length2();
+
+                        
+
+                        if (getDispatchInfo().m_useContinuous && body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion)
+                        {
+                                BT_PROFILE("CCD motion clamping");
+                                if (body->getCollisionShape()->isConvex())
+                                {
+                                        gNumClampedCcdMotions++;
+#ifdef USE_STATIC_ONLY
+                                        class StaticOnlyCallback : public btClosestNotMeConvexResultCallback
+                                        {
+                                        public:
+
+                                                StaticOnlyCallback (btCollisionObject* me,const btVector3& fromA,const btVector3& toA,btOverlappingPairCache* pairCache,btDispatcher* dispatcher) : 
+                                                  btClosestNotMeConvexResultCallback(me,fromA,toA,pairCache,dispatcher)
+                                                {
+                                                }
+
+                                                virtual bool needsCollision(btBroadphaseProxy* proxy0) const
+                                                {
+                                                        btCollisionObject* otherObj = (btCollisionObject*) proxy0->m_clientObject;
+                                                        if (!otherObj->isStaticOrKinematicObject())
+                                                                return false;
+                                                        return btClosestNotMeConvexResultCallback::needsCollision(proxy0);
+                                                }
+                                        };
+
+                                        StaticOnlyCallback sweepResults(body,body->getWorldTransform().getOrigin(),predictedTrans.getOrigin(),getBroadphase()->getOverlappingPairCache(),getDispatcher());
+#else
+                                        btClosestNotMeConvexResultCallback sweepResults(body,body->getWorldTransform().getOrigin(),predictedTrans.getOrigin(),getBroadphase()->getOverlappingPairCache(),getDispatcher());
+#endif
+                                        //btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
+                                        btSphereShape tmpSphere(body->getCcdSweptSphereRadius());//btConvexShape* convexShape = static_cast<btConvexShape*>(body->getCollisionShape());
+                                        sweepResults.m_allowedPenetration=getDispatchInfo().m_allowedCcdPenetration;
+
+                                        sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup;
+                                        sweepResults.m_collisionFilterMask  = body->getBroadphaseProxy()->m_collisionFilterMask;
+                                        btTransform modifiedPredictedTrans = predictedTrans;
+                                        modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis());
+
+                                        convexSweepTest(&tmpSphere,body->getWorldTransform(),modifiedPredictedTrans,sweepResults);
+                                        if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
+                                        {
+                                                
+                                                //printf("clamped integration to hit fraction = %f\n",fraction);
+                                                body->setHitFraction(sweepResults.m_closestHitFraction);
+                                                body->predictIntegratedTransform(timeStep*body->getHitFraction(), predictedTrans);
+                                                body->setHitFraction(0.f);
+                                                body->proceedToTransform( predictedTrans);
+
+#if 0
+                                                btVector3 linVel = body->getLinearVelocity();
+
+                                                btScalar maxSpeed = body->getCcdMotionThreshold()/getSolverInfo().m_timeStep;
+                                                btScalar maxSpeedSqr = maxSpeed*maxSpeed;
+                                                if (linVel.length2()>maxSpeedSqr)
+                                                {
+                                                        linVel.normalize();
+                                                        linVel*= maxSpeed;
+                                                        body->setLinearVelocity(linVel);
+                                                        btScalar ms2 = body->getLinearVelocity().length2();
+                                                        body->predictIntegratedTransform(timeStep, predictedTrans);
+
+                                                        btScalar sm2 = (predictedTrans.getOrigin()-body->getWorldTransform().getOrigin()).length2();
+                                                        btScalar smt = body->getCcdSquareMotionThreshold();
+                                                        printf("sm2=%f\n",sm2);
+                                                }
+#else
+                                                //response  between two dynamic objects without friction, assuming 0 penetration depth
+                                                btScalar appliedImpulse = 0.f;
+                                                btScalar depth = 0.f;
+                                                appliedImpulse = resolveSingleCollision(body,sweepResults.m_hitCollisionObject,sweepResults.m_hitPointWorld,sweepResults.m_hitNormalWorld,getSolverInfo(), depth);
+                                                
+
+#endif
+
+                                        continue;
+                                        }
+                                }
+                        }
+                        
+
+                        body->proceedToTransform( predictedTrans);
+                }
+        }
+}
+
+void    btDiscreteDynamicsWorld::addSpeculativeContacts(btScalar timeStep)
+{
+        BT_PROFILE("addSpeculativeContacts");
+        btTransform predictedTrans;
+        for ( int i=0;i<m_nonStaticRigidBodies.size();i++)
+        {
+                btRigidBody* body = m_nonStaticRigidBodies[i];
+                body->setHitFraction(1.f);
+
+                if (body->isActive() && (!body->isStaticOrKinematicObject()))
+                {
                         body->predictIntegratedTransform(timeStep, predictedTrans);
                         btScalar squareMotion = (predictedTrans.getOrigin()-body->getWorldTransform().getOrigin()).length2();
@@ -842 +963 @@
                         if (body->getCcdSquareMotionThreshold() && body->getCcdSquareMotionThreshold() < squareMotion)
                         {
-                                BT_PROFILE("CCD motion clamping");
+                                BT_PROFILE("search speculative contacts");
                                 if (body->getCollisionShape()->isConvex())
                                 {
@@ -853 +974 @@
                                         sweepResults.m_collisionFilterGroup = body->getBroadphaseProxy()->m_collisionFilterGroup;
                                         sweepResults.m_collisionFilterMask  = body->getBroadphaseProxy()->m_collisionFilterMask;
-
-                                        convexSweepTest(&tmpSphere,body->getWorldTransform(),predictedTrans,sweepResults);
+                                        btTransform modifiedPredictedTrans;
+                                        modifiedPredictedTrans = predictedTrans;
+                                        modifiedPredictedTrans.setBasis(body->getWorldTransform().getBasis());
+
+                                        convexSweepTest(&tmpSphere,body->getWorldTransform(),modifiedPredictedTrans,sweepResults);
                                         if (sweepResults.hasHit() && (sweepResults.m_closestHitFraction < 1.f))
                                         {
-                                                body->setHitFraction(sweepResults.m_closestHitFraction);
-                                                body->predictIntegratedTransform(timeStep*body->getHitFraction(), predictedTrans);
-                                                body->setHitFraction(0.f);
-//                                                      printf("clamped integration to hit fraction = %f\n",fraction);
+                                                btBroadphaseProxy* proxy0 = body->getBroadphaseHandle();
+                                                btBroadphaseProxy* proxy1 = sweepResults.m_hitCollisionObject->getBroadphaseHandle();
+                                                btBroadphasePair* pair = sweepResults.m_pairCache->findPair(proxy0,proxy1);
+                                                if (pair)
+                                                {
+                                                        if (pair->m_algorithm)
+                                                        {
+                                                                btManifoldArray contacts;
+                                                                pair->m_algorithm->getAllContactManifolds(contacts);
+                                                                if (contacts.size())
+                                                                {
+                                                                        btManifoldResult result(body,sweepResults.m_hitCollisionObject);
+                                                                        result.setPersistentManifold(contacts[0]);
+
+                                                                        btVector3 vec = (modifiedPredictedTrans.getOrigin()-body->getWorldTransform().getOrigin());
+                                                                        vec*=sweepResults.m_closestHitFraction;
+                                                                        
+                                                                        btScalar lenSqr = vec.length2();
+                                                                        btScalar depth = 0.f;
+                                                                        btVector3 pointWorld = sweepResults.m_hitPointWorld;
+                                                                        if (lenSqr>SIMD_EPSILON)
+                                                                        {
+                                                                                depth = btSqrt(lenSqr);
+                                                                                pointWorld -= vec;
+                                                                                vec /= depth;
+                                                                        }
+
+                                                                        if (contacts[0]->getBody0()==body)
+                                                                        {
+                                                                                result.addContactPoint(sweepResults.m_hitNormalWorld,pointWorld,depth);
+#if 0
+                                                                                debugContacts.push_back(sweepResults.m_hitPointWorld);//sweepResults.m_hitPointWorld);
+                                                                                debugNormals.push_back(sweepResults.m_hitNormalWorld);
+#endif
+                                                                        } else
+                                                                        {
+                                                                                //swapped
+                                                                                result.addContactPoint(-sweepResults.m_hitNormalWorld,pointWorld,depth);
+                                                                                //sweepResults.m_hitPointWorld,depth);
+                                                                                
+#if 0
+                                                                                if (1)//firstHit==1)
+                                                                                {
+                                                                                        firstHit=0;
+                                                                                        debugNormals.push_back(sweepResults.m_hitNormalWorld);
+                                                                                        debugContacts.push_back(pointWorld);//sweepResults.m_hitPointWorld);
+                                                                                        debugNormals.push_back(sweepResults.m_hitNormalWorld);
+                                                                                        debugContacts.push_back(sweepResults.m_hitPointWorld);
+                                                                                }
+                                                                                firstHit--;
+#endif
+                                                                        }
+                                                                }
+
+                                                        } else
+                                                        {
+                                                                //no algorithm, use dispatcher to create one
+
+                                                        }
+
+
+                                                } else
+                                                {
+                                                        //add an overlapping pair
+                                                        //printf("pair missing\n");
+
+                                                }
                                         }
                                 }
                         }
                         
-                        body->proceedToTransform( predictedTrans);
                 }
         }
@@ -1010 +1196 @@
                         }
                         break;
+                case D6_SPRING_CONSTRAINT_TYPE:
                 case D6_CONSTRAINT_TYPE:
                         {

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h

@@ -63 +63 @@
         virtual void    integrateTransforms(btScalar timeStep);
                 
+        virtual void    addSpeculativeContacts(btScalar timeStep);
+
         virtual void    calculateSimulationIslands();
 

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btDynamicsWorld.h

@@ -33 +33 @@
         BT_SIMPLE_DYNAMICS_WORLD=1,
         BT_DISCRETE_DYNAMICS_WORLD=2,
-        BT_CONTINUOUS_DYNAMICS_WORLD=3
+        BT_CONTINUOUS_DYNAMICS_WORLD=3,
+        BT_SOFT_RIGID_DYNAMICS_WORLD=4
 };
 
@@ -86 +87 @@
 
                 virtual void    addRigidBody(btRigidBody* body) = 0;
+
+                virtual void    addRigidBody(btRigidBody* body, short group, short mask) = 0;
 
                 virtual void    removeRigidBody(btRigidBody* body) = 0;

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btRigidBody.cpp

@@ -52 +52 @@
         m_totalForce.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0));
         m_totalTorque.setValue(btScalar(0.0), btScalar(0.0), btScalar(0.0)),
-        m_linearDamping = btScalar(0.);
-        m_angularDamping = btScalar(0.5);
+    setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
+
         m_linearSleepingThreshold = constructionInfo.m_linearSleepingThreshold;
         m_angularSleepingThreshold = constructionInfo.m_angularSleepingThreshold;
@@ -85 +85 @@
         
         setMassProps(constructionInfo.m_mass, constructionInfo.m_localInertia);
-    setDamping(constructionInfo.m_linearDamping, constructionInfo.m_angularDamping);
         updateInertiaTensor();
 

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btRigidBody.h

@@ -14 +14 @@
 */
 
-#ifndef RIGIDBODY_H
-#define RIGIDBODY_H
+#ifndef BT_RIGIDBODY_H
+#define BT_RIGIDBODY_H
 
 #include "LinearMath/btAlignedObjectArray.h"
@@ -90 +90 @@
         
         int                             m_debugBodyId;
-
+        
 
 protected:
@@ -271 +271 @@
         }
 
-        const btVector3& getTotalForce()
+        const btVector3& getTotalForce() const
         {
                 return m_totalForce;
         };
 
-        const btVector3& getTotalTorque()
+        const btVector3& getTotalTorque() const
         {
                 return m_totalTorque;
@@ -505 +505 @@
         }
 
-        int getNumConstraintRefs()
+        int getNumConstraintRefs() const
         {
                 return m_constraintRefs.size();
@@ -618 +618 @@
 
         void    internalWritebackVelocity(btScalar timeStep);
+
         
 
@@ -687 +688 @@
 
 
-#endif
-
+#endif //BT_RIGIDBODY_H
+

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btSimpleDynamicsWorld.cpp

@@ -79 +79 @@
                 infoGlobal.m_timeStep = timeStep;
                 m_constraintSolver->prepareSolve(0,numManifolds);
-                m_constraintSolver->solveGroup(0,0,manifoldPtr, numManifolds,0,0,infoGlobal,m_debugDrawer, m_stackAlloc,m_dispatcher1);
+                m_constraintSolver->solveGroup(&getCollisionObjectArray()[0],getNumCollisionObjects(),manifoldPtr, numManifolds,0,0,infoGlobal,m_debugDrawer, m_stackAlloc,m_dispatcher1);
                 m_constraintSolver->allSolved(infoGlobal,m_debugDrawer, m_stackAlloc);
         }
@@ -155 +155 @@
         }
 }
+
+void    btSimpleDynamicsWorld::addRigidBody(btRigidBody* body, short group, short mask)
+{
+        body->setGravity(m_gravity);
+
+        if (body->getCollisionShape())
+        {
+                addCollisionObject(body,group,mask);
+        }
+}
+
+
+void    btSimpleDynamicsWorld::debugDrawWorld()
+{
+
+}
+                                
+void    btSimpleDynamicsWorld::addAction(btActionInterface* action)
+{
+
+}
+
+void    btSimpleDynamicsWorld::removeAction(btActionInterface* action)
+{
+
+}
+
 
 void    btSimpleDynamicsWorld::updateAabbs()

code/trunk/src/external/bullet/BulletDynamics/Dynamics/btSimpleDynamicsWorld.h

@@ -57 +57 @@
         virtual void    addRigidBody(btRigidBody* body);
 
+        virtual void    addRigidBody(btRigidBody* body, short group, short mask);
+
         virtual void    removeRigidBody(btRigidBody* body);
+
+        virtual void    debugDrawWorld();
+                                
+        virtual void    addAction(btActionInterface* action);
+
+        virtual void    removeAction(btActionInterface* action);
 
         ///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject

code/trunk/src/external/bullet/BulletDynamics/Vehicle/btRaycastVehicle.cpp

@@ -22 +22 @@
 #include "LinearMath/btIDebugDraw.h"
 #include "BulletDynamics/ConstraintSolver/btContactConstraint.h"
+
+#define ROLLING_INFLUENCE_FIX
+
 
 btRigidBody& btActionInterface::getFixedBody()
@@ -695 +698 @@
                                         btVector3 sideImp = m_axle[wheel] * m_sideImpulse[wheel];
 
+#if defined ROLLING_INFLUENCE_FIX // fix. It only worked if car's up was along Y - VT.
+                                        btVector3 vChassisWorldUp = getRigidBody()->getCenterOfMassTransform().getBasis().getColumn(m_indexUpAxis);
+                                        rel_pos -= vChassisWorldUp * (vChassisWorldUp.dot(rel_pos) * (1.f-wheelInfo.m_rollInfluence));
+#else
                                         rel_pos[m_indexUpAxis] *= wheelInfo.m_rollInfluence;
+#endif
                                         m_chassisBody->applyImpulse(sideImp,rel_pos);
 

code/trunk/src/external/bullet/BulletDynamics/Vehicle/btRaycastVehicle.h

@@ -9 +9 @@
  * It is provided "as is" without express or implied warranty.
 */
-#ifndef RAYCASTVEHICLE_H
-#define RAYCASTVEHICLE_H
+#ifndef BT_RAYCASTVEHICLE_H
+#define BT_RAYCASTVEHICLE_H
 
 #include "BulletDynamics/Dynamics/btRigidBody.h"
@@ -113 +113 @@
         void    updateWheelTransform( int wheelIndex, bool interpolatedTransform = true );
         
-        void    setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth);
+//      void    setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth);
 
         btWheelInfo&    addWheel( const btVector3& connectionPointCS0, const btVector3& wheelDirectionCS0,const btVector3& wheelAxleCS,btScalar suspensionRestLength,btScalar wheelRadius,const btVehicleTuning& tuning, bool isFrontWheel);
@@ -233 +233 @@
 
 
-#endif //RAYCASTVEHICLE_H
-
+#endif //BT_RAYCASTVEHICLE_H
+

code/trunk/src/external/bullet/BulletDynamics/Vehicle/btVehicleRaycaster.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2005 Erwin Coumans http://continuousphysics.com/Bullet/
+ * Copyright (c) 2005 Erwin Coumans http://bulletphysics.org
  *
  * Permission to use, copy, modify, distribute and sell this software
@@ -9 +9 @@
  * It is provided "as is" without express or implied warranty.
 */
-#ifndef VEHICLE_RAYCASTER_H
-#define VEHICLE_RAYCASTER_H
+#ifndef BT_VEHICLE_RAYCASTER_H
+#define BT_VEHICLE_RAYCASTER_H
 
 #include "LinearMath/btVector3.h"
@@ -32 +32 @@
 };
 
-#endif //VEHICLE_RAYCASTER_H
+#endif //BT_VEHICLE_RAYCASTER_H
 

code/trunk/src/external/bullet/BulletDynamics/Vehicle/btWheelInfo.h

@@ -9 +9 @@
  * It is provided "as is" without express or implied warranty.
 */
-#ifndef WHEEL_INFO_H
-#define WHEEL_INFO_H
+#ifndef BT_WHEEL_INFO_H
+#define BT_WHEEL_INFO_H
 
 #include "LinearMath/btVector3.h"
@@ -116 +116 @@
 };
 
-#endif //WHEEL_INFO_H
+#endif //BT_WHEEL_INFO_H