Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
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/ConstraintSolver
Files:
23 edited

Legend:

Unmodified
Added
Removed

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

    r8351 r8393  
    11151115
    11161116
    1117 
     1117void btConeTwistConstraint::setFrames(const btTransform & frameA, const btTransform & frameB)
     1118{
     1119        m_rbAFrame = frameA;
     1120        m_rbBFrame = frameB;
     1121        buildJacobian();
     1122        //calculateTransforms();
     1123}
     1124
     1125 
     1126
     1127

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

    r8351 r8393  
    3434
    3535
    36 #ifndef CONETWISTCONSTRAINT_H
    37 #define CONETWISTCONSTRAINT_H
     36#ifndef BT_CONETWISTCONSTRAINT_H
     37#define BT_CONETWISTCONSTRAINT_H
    3838
    3939#include "LinearMath/btVector3.h"
    … …  
    144144
    145145        void    updateRHS(btScalar      timeStep);
     146
    146147
    147148        const btRigidBody& getRigidBodyA() const
    … …  
    245246        bool isPastSwingLimit() { return m_solveSwingLimit; }
    246247
    247 
    248248        void setDamping(btScalar damping) { m_damping = damping; }
    249249
    … …  
    269269        ///If no axis is provided, it uses the default axis for this constraint.
    270270        virtual void setParam(int num, btScalar value, int axis = -1);
     271
     272        virtual void setFrames(const btTransform& frameA, const btTransform& frameB);
     273
     274        const btTransform& getFrameOffsetA() const
     275        {
     276                return m_rbAFrame;
     277        }
     278
     279        const btTransform& getFrameOffsetB() const
     280        {
     281                return m_rbBFrame;
     282        }
     283
     284
    271285        ///return the local value of parameter
    272286        virtual btScalar getParam(int num, int axis = -1) const;
    … …  
    330344
    331345
    332 #endif //CONETWISTCONSTRAINT_H
     346#endif //BT_CONETWISTCONSTRAINT_H

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

    r5781 r8393  
    1414*/
    1515
    16 #ifndef CONSTRAINT_SOLVER_H
    17 #define CONSTRAINT_SOLVER_H
     16#ifndef BT_CONSTRAINT_SOLVER_H
     17#define BT_CONSTRAINT_SOLVER_H
    1818
    1919#include "LinearMath/btScalar.h"
    … …  
    5050
    5151
    52 #endif //CONSTRAINT_SOLVER_H
     52#endif //BT_CONSTRAINT_SOLVER_H

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

    r8351 r8393  
    6969#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"
    7070
    71 #define ASSERT2 btAssert
    7271
    73 #define USE_INTERNAL_APPLY_IMPULSE 1
     72
     73//response  between two dynamic objects without friction, assuming 0 penetration depth
     74btScalar resolveSingleCollision(
     75        btRigidBody* body1,
     76        btCollisionObject* colObj2,
     77                const btVector3& contactPositionWorld,
     78                const btVector3& contactNormalOnB,
     79        const btContactSolverInfo& solverInfo,
     80                btScalar distance)
     81{
     82        btRigidBody* body2 = btRigidBody::upcast(colObj2);
     83   
     84       
     85    const btVector3& normal = contactNormalOnB;
     86
     87    btVector3 rel_pos1 = contactPositionWorld - body1->getWorldTransform().getOrigin();
     88    btVector3 rel_pos2 = contactPositionWorld - colObj2->getWorldTransform().getOrigin();
     89   
     90    btVector3 vel1 = body1->getVelocityInLocalPoint(rel_pos1);
     91        btVector3 vel2 = body2? body2->getVelocityInLocalPoint(rel_pos2) : btVector3(0,0,0);
     92    btVector3 vel = vel1 - vel2;
     93    btScalar rel_vel;
     94    rel_vel = normal.dot(vel);
     95   
     96    btScalar combinedRestitution = body1->getRestitution() * colObj2->getRestitution();
     97    btScalar restitution = combinedRestitution* -rel_vel;
     98
     99    btScalar positionalError = solverInfo.m_erp *-distance /solverInfo.m_timeStep ;
     100    btScalar velocityError = -(1.0f + restitution) * rel_vel;// * damping;
     101        btScalar denom0 = body1->computeImpulseDenominator(contactPositionWorld,normal);
     102        btScalar denom1 = body2? body2->computeImpulseDenominator(contactPositionWorld,normal) : 0.f;
     103        btScalar relaxation = 1.f;
     104        btScalar jacDiagABInv = relaxation/(denom0+denom1);
     105
     106    btScalar penetrationImpulse = positionalError * jacDiagABInv;
     107    btScalar velocityImpulse = velocityError * jacDiagABInv;
     108
     109    btScalar normalImpulse = penetrationImpulse+velocityImpulse;
     110    normalImpulse = 0.f > normalImpulse ? 0.f: normalImpulse;
     111
     112        body1->applyImpulse(normal*(normalImpulse), rel_pos1);
     113    if (body2)
     114                body2->applyImpulse(-normal*(normalImpulse), rel_pos2);
     115   
     116    return normalImpulse;
     117}
    74118
    75119
    … …  
    84128
    85129        btScalar normalLenSqr = normal.length2();
    86         ASSERT2(btFabs(normalLenSqr) < btScalar(1.1));
     130        btAssert(btFabs(normalLenSqr) < btScalar(1.1));
    87131        if (normalLenSqr > btScalar(1.1))
    88132        {

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONTACT_CONSTRAINT_H
    17 #define CONTACT_CONSTRAINT_H
     16#ifndef BT_CONTACT_CONSTRAINT_H
     17#define BT_CONTACT_CONSTRAINT_H
    1818
    1919#include "LinearMath/btVector3.h"
    … …  
    5858};
    5959
     60///very basic collision resolution without friction
     61btScalar resolveSingleCollision(btRigidBody* body1, class btCollisionObject* colObj2, const btVector3& contactPositionWorld,const btVector3& contactNormalOnB, const struct btContactSolverInfo& solverInfo,btScalar distance);
     62
    6063
    6164///resolveSingleBilateral is an obsolete methods used for vehicle friction between two dynamic objects
    … …  
    6669
    6770
    68 #endif //CONTACT_CONSTRAINT_H
     71#endif //BT_CONTACT_CONSTRAINT_H

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONTACT_SOLVER_INFO
    17 #define CONTACT_SOLVER_INFO
     16#ifndef BT_CONTACT_SOLVER_INFO
     17#define BT_CONTACT_SOLVER_INFO
    1818
    1919enum    btSolverMode
    … …  
    8585};
    8686
    87 #endif //CONTACT_SOLVER_INFO
     87#endif //BT_CONTACT_SOLVER_INFO

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

    r8351 r8393  
    711711        (void)timeStep;
    712712
     713}
     714
     715
     716void btGeneric6DofConstraint::setFrames(const btTransform& frameA, const btTransform& frameB)
     717{
     718        m_frameInA = frameA;
     719        m_frameInB = frameB;
     720        buildJacobian();
     721        calculateTransforms();
    713722}
    714723
    … …  
    10391048        return retVal;
    10401049}
     1050
     1051 
     1052
     1053void btGeneric6DofConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
     1054{
     1055        btVector3 zAxis = axis1.normalized();
     1056        btVector3 yAxis = axis2.normalized();
     1057        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
     1058       
     1059        btTransform frameInW;
     1060        frameInW.setIdentity();
     1061        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
     1062                                        xAxis[1], yAxis[1], zAxis[1],
     1063                                       xAxis[2], yAxis[2], zAxis[2]);
     1064       
     1065        // now get constraint frame in local coordinate systems
     1066        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
     1067        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
     1068       
     1069        calculateTransforms();
     1070}

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

    r8351 r8393  
    2525
    2626
    27 #ifndef GENERIC_6DOF_CONSTRAINT_H
    28 #define GENERIC_6DOF_CONSTRAINT_H
     27#ifndef BT_GENERIC_6DOF_CONSTRAINT_H
     28#define BT_GENERIC_6DOF_CONSTRAINT_H
    2929
    3030#include "LinearMath/btVector3.h"
    … …  
    434434        btScalar getRelativePivotPosition(int axis_index) const;
    435435
     436        void setFrames(const btTransform & frameA, const btTransform & frameB);
    436437
    437438        //! Test angular limit.
    … …  
    447448    }
    448449
    449     void        setLinearUpperLimit(const btVector3& linearUpper)
    450     {
    451         m_linearLimits.m_upperLimit = linearUpper;
    452     }
     450        void    getLinearLowerLimit(btVector3& linearLower)
     451        {
     452                linearLower = m_linearLimits.m_lowerLimit;
     453        }
     454
     455        void    setLinearUpperLimit(const btVector3& linearUpper)
     456        {
     457                m_linearLimits.m_upperLimit = linearUpper;
     458        }
     459
     460        void    getLinearUpperLimit(btVector3& linearUpper)
     461        {
     462                linearUpper = m_linearLimits.m_upperLimit;
     463        }
    453464
    454465    void        setAngularLowerLimit(const btVector3& angularLower)
    … …  
    458469    }
    459470
     471        void    getAngularLowerLimit(btVector3& angularLower)
     472        {
     473                for(int i = 0; i < 3; i++)
     474                        angularLower[i] = m_angularLimits[i].m_loLimit;
     475        }
     476
    460477    void        setAngularUpperLimit(const btVector3& angularUpper)
    461478    {
    … …  
    463480                        m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
    464481    }
     482
     483        void    getAngularUpperLimit(btVector3& angularUpper)
     484        {
     485                for(int i = 0; i < 3; i++)
     486                        angularUpper[i] = m_angularLimits[i].m_hiLimit;
     487        }
    465488
    466489        //! Retrieves the angular limit informacion
    … …  
    526549        virtual btScalar getParam(int num, int axis = -1) const;
    527550
     551        void setAxis( const btVector3& axis1, const btVector3& axis2);
     552
     553
    528554        virtual int     calculateSerializeBufferSize() const;
    529555
    … …  
    586612
    587613
    588 #endif //GENERIC_6DOF_CONSTRAINT_H
     614#endif //BT_GENERIC_6DOF_CONSTRAINT_H

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

    r8351 r8393  
    2222        : btGeneric6DofConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA)
    2323{
     24        m_objectType = D6_SPRING_CONSTRAINT_TYPE;
     25
    2426        for(int i = 0; i < 6; i++)
    2527        {
    … …  
    148150
    149151
     152void btGeneric6DofSpringConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
     153{
     154        btVector3 zAxis = axis1.normalized();
     155        btVector3 yAxis = axis2.normalized();
     156        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
     157
     158        btTransform frameInW;
     159        frameInW.setIdentity();
     160        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
     161                                xAxis[1], yAxis[1], zAxis[1],
     162                                xAxis[2], yAxis[2], zAxis[2]);
     163
     164        // now get constraint frame in local coordinate systems
     165        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
     166        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
     167
     168  calculateTransforms();
     169}
    150170
    151171
     172

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef GENERIC_6DOF_SPRING_CONSTRAINT_H
    17 #define GENERIC_6DOF_SPRING_CONSTRAINT_H
     16#ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
     17#define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
    1818
    1919
    … …  
    4949        void setEquilibriumPoint(int index);  // set the current constraint position/orientation as an equilibrium point for given DOF
    5050        void setEquilibriumPoint(int index, btScalar val);
     51
     52        virtual void setAxis( const btVector3& axis1, const btVector3& axis2);
     53
    5154        virtual void getInfo2 (btConstraintInfo2* info);
     55
     56        virtual int     calculateSerializeBufferSize() const;
     57        ///fills the dataBuffer and returns the struct name (and 0 on failure)
     58        virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
     59
    5260};
    5361
    54 #endif // GENERIC_6DOF_SPRING_CONSTRAINT_H
    5562
     63///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
     64struct btGeneric6DofSpringConstraintData
     65{
     66        btGeneric6DofConstraintData     m_6dofData;
     67       
     68        int                     m_springEnabled[6];
     69        float           m_equilibriumPoint[6];
     70        float           m_springStiffness[6];
     71        float           m_springDamping[6];
     72};
     73
     74SIMD_FORCE_INLINE       int     btGeneric6DofSpringConstraint::calculateSerializeBufferSize() const
     75{
     76        return sizeof(btGeneric6DofSpringConstraintData);
     77}
     78
     79        ///fills the dataBuffer and returns the struct name (and 0 on failure)
     80SIMD_FORCE_INLINE       const char*     btGeneric6DofSpringConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
     81{
     82        btGeneric6DofSpringConstraintData* dof = (btGeneric6DofSpringConstraintData*)dataBuffer;
     83        btGeneric6DofConstraint::serialize(&dof->m_6dofData,serializer);
     84
     85        int i;
     86        for (i=0;i<6;i++)
     87        {
     88                dof->m_equilibriumPoint[i] = m_equilibriumPoint[i];
     89                dof->m_springDamping[i] = m_springDamping[i];
     90                dof->m_springEnabled[i] = m_springEnabled[i]? 1 : 0;
     91                dof->m_springStiffness[i] = m_springStiffness[i];
     92        }
     93        return "btGeneric6DofConstraintData";
     94}
     95
     96#endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
     97

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef HINGE2_CONSTRAINT_H
    17 #define HINGE2_CONSTRAINT_H
     16#ifndef BT_HINGE2_CONSTRAINT_H
     17#define BT_HINGE2_CONSTRAINT_H
    1818
    1919
    … …  
    5555
    5656
    57 #endif // HINGE2_CONSTRAINT_H
     57#endif // BT_HINGE2_CONSTRAINT_H
    5858

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

    r8351 r8393  
    4444                                                                         m_useReferenceFrameA(useReferenceFrameA),
    4545                                                                         m_flags(0)
     46#ifdef _BT_USE_CENTER_LIMIT_
     47                                                                        ,m_limit()
     48#endif
    4649{
    4750        m_rbAFrame.getOrigin() = pivotInA;
    … …  
    7679                                                                        rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
    7780       
     81#ifndef _BT_USE_CENTER_LIMIT_
    7882        //start with free
    7983        m_lowerLimit = btScalar(1.0f);
    … …  
    8387        m_limitSoftness = 0.9f;
    8488        m_solveLimit = false;
     89#endif
    8590        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    8691}
    … …  
    9499m_useReferenceFrameA(useReferenceFrameA),
    95100m_flags(0)
     101#ifdef  _BT_USE_CENTER_LIMIT_
     102,m_limit()
     103#endif
    96104{
    97105
    … …  
    118126                                                                        rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
    119127       
     128#ifndef _BT_USE_CENTER_LIMIT_
    120129        //start with free
    121130        m_lowerLimit = btScalar(1.0f);
    … …  
    125134        m_limitSoftness = 0.9f;
    126135        m_solveLimit = false;
     136#endif
    127137        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    128138}
    … …  
    139149m_useReferenceFrameA(useReferenceFrameA),
    140150m_flags(0)
    141 {
     151#ifdef  _BT_USE_CENTER_LIMIT_
     152,m_limit()
     153#endif
     154{
     155#ifndef _BT_USE_CENTER_LIMIT_
    142156        //start with free
    143157        m_lowerLimit = btScalar(1.0f);
    … …  
    147161        m_limitSoftness = 0.9f;
    148162        m_solveLimit = false;
     163#endif
    149164        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    150165}                       
    … …  
    160175m_useReferenceFrameA(useReferenceFrameA),
    161176m_flags(0)
     177#ifdef  _BT_USE_CENTER_LIMIT_
     178,m_limit()
     179#endif
    162180{
    163181        ///not providing rigidbody B means implicitly using worldspace for body B
    164182
    165183        m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(m_rbAFrame.getOrigin());
    166 
     184#ifndef _BT_USE_CENTER_LIMIT_
    167185        //start with free
    168186        m_lowerLimit = btScalar(1.0f);
    … …  
    172190        m_limitSoftness = 0.9f;
    173191        m_solveLimit = false;
     192#endif
    174193        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    175194}
    … …  
    450469        if(getSolveLimit())
    451470        {
    452                 limit_err = m_correction * m_referenceSign;
    453                 limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     471#ifdef  _BT_USE_CENTER_LIMIT_
     472        limit_err = m_limit.getCorrection() * m_referenceSign;
     473#else
     474        limit_err = m_correction * m_referenceSign;
     475#endif
     476        limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     477
    454478        }
    455479        // if the hinge has joint limits or motor, add in the extra row
    … …  
    515539                        }
    516540                        // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that)
     541#ifdef  _BT_USE_CENTER_LIMIT_
     542                        btScalar bounce = m_limit.getRelaxationFactor();
     543#else
    517544                        btScalar bounce = m_relaxationFactor;
     545#endif
    518546                        if(bounce > btScalar(0.0))
    519547                        {
    … …  
    545573                                }
    546574                        }
     575#ifdef  _BT_USE_CENTER_LIMIT_
     576                        info->m_constraintError[srow] *= m_limit.getBiasFactor();
     577#else
    547578                        info->m_constraintError[srow] *= m_biasFactor;
     579#endif
    548580                } // if(limit)
    549581        } // if angular limit or powered
    … …  
    551583
    552584
    553 
    554 
     585void btHingeConstraint::setFrames(const btTransform & frameA, const btTransform & frameB)
     586{
     587        m_rbAFrame = frameA;
     588        m_rbBFrame = frameB;
     589        buildJacobian();
     590}
    555591
    556592
    … …  
    578614
    579615
    580 #if 0
    581 void btHingeConstraint::testLimit()
    582 {
    583         // Compute limit information
    584         m_hingeAngle = getHingeAngle(); 
    585         m_correction = btScalar(0.);
    586         m_limitSign = btScalar(0.);
    587         m_solveLimit = false;
    588         if (m_lowerLimit <= m_upperLimit)
    589         {
    590                 if (m_hingeAngle <= m_lowerLimit)
    591                 {
    592                         m_correction = (m_lowerLimit - m_hingeAngle);
    593                         m_limitSign = 1.0f;
    594                         m_solveLimit = true;
    595                 }
    596                 else if (m_hingeAngle >= m_upperLimit)
    597                 {
    598                         m_correction = m_upperLimit - m_hingeAngle;
    599                         m_limitSign = -1.0f;
    600                         m_solveLimit = true;
    601                 }
    602         }
    603         return;
    604 }
    605 #else
    606 
    607616
    608617void btHingeConstraint::testLimit(const btTransform& transA,const btTransform& transB)
    … …  
    610619        // Compute limit information
    611620        m_hingeAngle = getHingeAngle(transA,transB);
     621#ifdef  _BT_USE_CENTER_LIMIT_
     622        m_limit.test(m_hingeAngle);
     623#else
    612624        m_correction = btScalar(0.);
    613625        m_limitSign = btScalar(0.);
    … …  
    629641                }
    630642        }
     643#endif
    631644        return;
    632645}
    633 #endif
     646
    634647
    635648static btVector3 vHinge(0, 0, btScalar(1));
    … …  
    662675void btHingeConstraint::setMotorTarget(btScalar targetAngle, btScalar dt)
    663676{
     677#ifdef  _BT_USE_CENTER_LIMIT_
     678        m_limit.fit(targetAngle);
     679#else
    664680        if (m_lowerLimit < m_upperLimit)
    665681        {
    … …  
    669685                        targetAngle = m_upperLimit;
    670686        }
    671 
     687#endif
    672688        // compute angular velocity
    673689        btScalar curAngle  = getHingeAngle(m_rbA.getCenterOfMassTransform(),m_rbB.getCenterOfMassTransform());
    … …  
    840856        if(getSolveLimit())
    841857        {
    842                 limit_err = m_correction * m_referenceSign;
    843                 limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     858#ifdef  _BT_USE_CENTER_LIMIT_
     859        limit_err = m_limit.getCorrection() * m_referenceSign;
     860#else
     861        limit_err = m_correction * m_referenceSign;
     862#endif
     863        limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     864
    844865        }
    845866        // if the hinge has joint limits or motor, add in the extra row
    … …  
    905926                        }
    906927                        // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that)
     928#ifdef  _BT_USE_CENTER_LIMIT_
     929                        btScalar bounce = m_limit.getRelaxationFactor();
     930#else
    907931                        btScalar bounce = m_relaxationFactor;
     932#endif
    908933                        if(bounce > btScalar(0.0))
    909934                        {
    … …  
    935960                                }
    936961                        }
     962#ifdef  _BT_USE_CENTER_LIMIT_
     963                        info->m_constraintError[srow] *= m_limit.getBiasFactor();
     964#else
    937965                        info->m_constraintError[srow] *= m_biasFactor;
     966#endif
    938967                } // if(limit)
    939968        } // if angular limit or powered

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

    r8351 r8393  
    1616/* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */
    1717
    18 #ifndef HINGECONSTRAINT_H
    19 #define HINGECONSTRAINT_H
     18#ifndef BT_HINGECONSTRAINT_H
     19#define BT_HINGECONSTRAINT_H
     20
     21#define _BT_USE_CENTER_LIMIT_ 1
     22
    2023
    2124#include "LinearMath/btVector3.h"
    … …  
    3235#define btHingeConstraintDataName       "btHingeConstraintFloatData"
    3336#endif //BT_USE_DOUBLE_PRECISION
     37
    3438
    3539
    … …  
    5862        btScalar        m_maxMotorImpulse;
    5963
     64
     65#ifdef  _BT_USE_CENTER_LIMIT_
     66        btAngularLimit  m_limit;
     67#else
     68        btScalar        m_lowerLimit;   
     69        btScalar        m_upperLimit;   
     70        btScalar        m_limitSign;
     71        btScalar        m_correction;
     72
    6073        btScalar        m_limitSoftness;
    6174        btScalar        m_biasFactor;
    62         btScalar    m_relaxationFactor;
    63 
    64         btScalar    m_lowerLimit;       
    65         btScalar    m_upperLimit;       
    66        
     75        btScalar        m_relaxationFactor;
     76
     77        bool            m_solveLimit;
     78#endif
     79
    6780        btScalar        m_kHinge;
    6881
    69         btScalar        m_limitSign;
    70         btScalar        m_correction;
    7182
    7283        btScalar        m_accLimitImpulse;
    7384        btScalar        m_hingeAngle;
    74         btScalar    m_referenceSign;
     85        btScalar        m_referenceSign;
    7586
    7687        bool            m_angularOnly;
    7788        bool            m_enableAngularMotor;
    78         bool            m_solveLimit;
    7989        bool            m_useSolveConstraintObsolete;
    8090        bool            m_useOffsetForConstraintFrame;
    … …  
    133143        {               
    134144                return m_rbB;   
    135         }       
     145        }
     146
     147        btTransform& getFrameOffsetA()
     148        {
     149        return m_rbAFrame;
     150        }
     151
     152        btTransform& getFrameOffsetB()
     153        {
     154                return m_rbBFrame;
     155        }
     156
     157        void setFrames(const btTransform& frameA, const btTransform& frameB);
    136158       
    137159        void    setAngularOnly(bool angularOnly)
    … …  
    158180        void    setLimit(btScalar low,btScalar high,btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f)
    159181        {
     182#ifdef  _BT_USE_CENTER_LIMIT_
     183                m_limit.set(low, high, _softness, _biasFactor, _relaxationFactor);
     184#else
    160185                m_lowerLimit = btNormalizeAngle(low);
    161186                m_upperLimit = btNormalizeAngle(high);
    162 
    163187                m_limitSoftness =  _softness;
    164188                m_biasFactor = _biasFactor;
    165189                m_relaxationFactor = _relaxationFactor;
    166 
     190#endif
    167191        }
    168192
    … …  
    183207                btVector3 rbAxisB2 = axisInB.cross(rbAxisB1);
    184208
    185 
    186                 m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(pivotInA);
     209                m_rbBFrame.getOrigin() = m_rbB.getCenterOfMassTransform().inverse()(m_rbA.getCenterOfMassTransform()(pivotInA));
     210
    187211                m_rbBFrame.getBasis().setValue( rbAxisB1.getX(),rbAxisB2.getX(),axisInB.getX(),
    188212                                                                                rbAxisB1.getY(),rbAxisB2.getY(),axisInB.getY(),
    189213                                                                                rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
     214                m_rbBFrame.getBasis() = m_rbB.getCenterOfMassTransform().getBasis().inverse() * m_rbBFrame.getBasis();
     215
    190216        }
    191217
    192218        btScalar        getLowerLimit() const
    193219        {
    194                 return m_lowerLimit;
     220#ifdef  _BT_USE_CENTER_LIMIT_
     221        return m_limit.getLow();
     222#else
     223        return m_lowerLimit;
     224#endif
    195225        }
    196226
    197227        btScalar        getUpperLimit() const
    198228        {
    199                 return m_upperLimit;
     229#ifdef  _BT_USE_CENTER_LIMIT_
     230        return m_limit.getHigh();
     231#else           
     232        return m_upperLimit;
     233#endif
    200234        }
    201235
    … …  
    216250        inline int getSolveLimit()
    217251        {
    218                 return m_solveLimit;
     252#ifdef  _BT_USE_CENTER_LIMIT_
     253        return m_limit.isLimit();
     254#else
     255        return m_solveLimit;
     256#endif
    219257        }
    220258
    221259        inline btScalar getLimitSign()
    222260        {
     261#ifdef  _BT_USE_CENTER_LIMIT_
     262        return m_limit.getSign();
     263#else
    223264                return m_limitSign;
     265#endif
    224266        }
    225267
    … …  
    320362        hingeData->m_motorTargetVelocity = float(m_motorTargetVelocity);
    321363        hingeData->m_useReferenceFrameA = m_useReferenceFrameA;
    322        
     364#ifdef  _BT_USE_CENTER_LIMIT_
     365        hingeData->m_lowerLimit = float(m_limit.getLow());
     366        hingeData->m_upperLimit = float(m_limit.getHigh());
     367        hingeData->m_limitSoftness = float(m_limit.getSoftness());
     368        hingeData->m_biasFactor = float(m_limit.getBiasFactor());
     369        hingeData->m_relaxationFactor = float(m_limit.getRelaxationFactor());
     370#else
    323371        hingeData->m_lowerLimit = float(m_lowerLimit);
    324372        hingeData->m_upperLimit = float(m_upperLimit);
    … …  
    326374        hingeData->m_biasFactor = float(m_biasFactor);
    327375        hingeData->m_relaxationFactor = float(m_relaxationFactor);
     376#endif
    328377
    329378        return btHingeConstraintDataName;
    330379}
    331380
    332 #endif //HINGECONSTRAINT_H
     381#endif //BT_HINGECONSTRAINT_H

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef JACOBIAN_ENTRY_H
    17 #define JACOBIAN_ENTRY_H
     16#ifndef BT_JACOBIAN_ENTRY_H
     17#define BT_JACOBIAN_ENTRY_H
    1818
    1919#include "LinearMath/btVector3.h"
    … …  
    154154};
    155155
    156 #endif //JACOBIAN_ENTRY_H
     156#endif //BT_JACOBIAN_ENTRY_H

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef POINT2POINTCONSTRAINT_H
    17 #define POINT2POINTCONSTRAINT_H
     16#ifndef BT_POINT2POINTCONSTRAINT_H
     17#define BT_POINT2POINTCONSTRAINT_H
    1818
    1919#include "LinearMath/btVector3.h"
    … …  
    159159}
    160160
    161 #endif //POINT2POINTCONSTRAINT_H
     161#endif //BT_POINT2POINTCONSTRAINT_H

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

    r8351 r8393  
    4949#ifdef USE_SIMD
    5050#include <emmintrin.h>
    51 #define vec_splat(x, e) _mm_shuffle_ps(x, x, _MM_SHUFFLE(e,e,e,e))
    52 static inline __m128 _vmathVfDot3( __m128 vec0, __m128 vec1 )
     51#define btVecSplat(x, e) _mm_shuffle_ps(x, x, _MM_SHUFFLE(e,e,e,e))
     52static inline __m128 btSimdDot3( __m128 vec0, __m128 vec1 )
    5353{
    5454        __m128 result = _mm_mul_ps( vec0, vec1);
    55         return _mm_add_ps( vec_splat( result, 0 ), _mm_add_ps( vec_splat( result, 1 ), vec_splat( result, 2 ) ) );
     55        return _mm_add_ps( btVecSplat( result, 0 ), _mm_add_ps( btVecSplat( result, 1 ), btVecSplat( result, 2 ) ) );
    5656}
    5757#endif//USE_SIMD
    … …  
    6565        __m128  upperLimit1 = _mm_set1_ps(c.m_upperLimit);
    6666        __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)));
    67         __m128 deltaVel1Dotn    =       _mm_add_ps(_vmathVfDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), _vmathVfDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
    68         __m128 deltaVel2Dotn    =       _mm_sub_ps(_vmathVfDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),_vmathVfDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
     67        __m128 deltaVel1Dotn    =       _mm_add_ps(btSimdDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
     68        __m128 deltaVel2Dotn    =       _mm_sub_ps(btSimdDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),btSimdDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
    6969        deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel1Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
    7070        deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel2Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
    … …  
    128128        __m128  upperLimit1 = _mm_set1_ps(c.m_upperLimit);
    129129        __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)));
    130         __m128 deltaVel1Dotn    =       _mm_add_ps(_vmathVfDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), _vmathVfDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
    131         __m128 deltaVel2Dotn    =       _mm_sub_ps(_vmathVfDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),_vmathVfDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
     130        __m128 deltaVel1Dotn    =       _mm_add_ps(btSimdDot3(c.m_contactNormal.mVec128,body1.internalGetDeltaLinearVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetDeltaAngularVelocity().mVec128));
     131        __m128 deltaVel2Dotn    =       _mm_sub_ps(btSimdDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetDeltaAngularVelocity().mVec128),btSimdDot3((c.m_contactNormal).mVec128,body2.internalGetDeltaLinearVelocity().mVec128));
    132132        deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel1Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
    133133        deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel2Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
    … …  
    216216        __m128  upperLimit1 = _mm_set1_ps(c.m_upperLimit);
    217217        __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)));
    218         __m128 deltaVel1Dotn    =       _mm_add_ps(_vmathVfDot3(c.m_contactNormal.mVec128,body1.internalGetPushVelocity().mVec128), _vmathVfDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetTurnVelocity().mVec128));
    219         __m128 deltaVel2Dotn    =       _mm_sub_ps(_vmathVfDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetTurnVelocity().mVec128),_vmathVfDot3((c.m_contactNormal).mVec128,body2.internalGetPushVelocity().mVec128));
     218        __m128 deltaVel1Dotn    =       _mm_add_ps(btSimdDot3(c.m_contactNormal.mVec128,body1.internalGetPushVelocity().mVec128), btSimdDot3(c.m_relpos1CrossNormal.mVec128,body1.internalGetTurnVelocity().mVec128));
     219        __m128 deltaVel2Dotn    =       _mm_sub_ps(btSimdDot3(c.m_relpos2CrossNormal.mVec128,body2.internalGetTurnVelocity().mVec128),btSimdDot3((c.m_contactNormal).mVec128,body2.internalGetPushVelocity().mVec128));
    220220        deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel1Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
    221221        deltaImpulse    =       _mm_sub_ps(deltaImpulse,_mm_mul_ps(deltaVel2Dotn,_mm_set1_ps(c.m_jacDiagABInv)));
    … …  
    558558
    559559                                        btScalar positionalError = 0.f;
    560                                         positionalError = -penetration * infoGlobal.m_erp/infoGlobal.m_timeStep;
    561560                                        btScalar        velocityError = restitution - rel_vel;// * damping;
     561
     562                                        if (penetration>0)
     563                                        {
     564                                                positionalError = 0;
     565                                                velocityError -= penetration / infoGlobal.m_timeStep;
     566                                        } else
     567                                        {
     568                                                positionalError = -penetration * infoGlobal.m_erp/infoGlobal.m_timeStep;
     569                                        }
     570
    562571                                        btScalar  penetrationImpulse = positionalError*solverConstraint.m_jacDiagABInv;
    563572                                        btScalar velocityImpulse = velocityError *solverConstraint.m_jacDiagABInv;
    … …  
    780789                        btTypedConstraint* constraint = constraints[j];
    781790                        constraint->buildJacobian();
     791                        constraint->internalSetAppliedImpulse(0.0f);
    782792                }
    783793        }
    … …  
    796806                        {
    797807                                btTypedConstraint::btConstraintInfo1& info1 = m_tmpConstraintSizesPool[i];
    798                                 constraints[i]->getInfo1(&info1);
     808                                if (constraints[i]->isEnabled())
     809                                {
     810                                        constraints[i]->getInfo1(&info1);
     811                                } else
     812                                {
     813                                        info1.m_numConstraintRows = 0;
     814                                        info1.nub = 0;
     815                                }
    799816                                totalNumRows += info1.m_numConstraintRows;
    800817                        }
    … …  
    817834
    818835
    819 
    820836                                        btRigidBody& rbA = constraint->getRigidBodyA();
    821837                                        btRigidBody& rbB = constraint->getRigidBodyB();
    … …  
    826842                                        {
    827843                                                memset(&currentConstraintRow[j],0,sizeof(btSolverConstraint));
    828                                                 currentConstraintRow[j].m_lowerLimit = -FLT_MAX;
    829                                                 currentConstraintRow[j].m_upperLimit = FLT_MAX;
     844                                                currentConstraintRow[j].m_lowerLimit = -SIMD_INFINITY;
     845                                                currentConstraintRow[j].m_upperLimit = SIMD_INFINITY;
    830846                                                currentConstraintRow[j].m_appliedImpulse = 0.f;
    831847                                                currentConstraintRow[j].m_appliedPushImpulse = 0.f;
    … …  
    860876                                        constraints[i]->getInfo2(&info2);
    861877
     878                                        if (currentConstraintRow->m_upperLimit>constraints[i]->getBreakingImpulseThreshold())
     879                                        {
     880                                                currentConstraintRow->m_upperLimit = constraints[i]->getBreakingImpulseThreshold();
     881                                        }
     882
     883                                        if (currentConstraintRow->m_lowerLimit<-constraints[i]->getBreakingImpulseThreshold())
     884                                        {
     885                                                currentConstraintRow->m_lowerLimit = -constraints[i]->getBreakingImpulseThreshold();
     886                                        }
     887
     888
     889
    862890                                        ///finalize the constraint setup
    863891                                        for ( j=0;j<info1.m_numConstraintRows;j++)
    … …  
    11071135        int iteration;
    11081136        {
     1137                solveGroupCacheFriendlySplitImpulseIterations(bodies ,numBodies,manifoldPtr, numManifolds,constraints,numConstraints,infoGlobal,debugDrawer,stackAlloc);
     1138
    11091139                for ( iteration = 0;iteration<infoGlobal.m_numIterations;iteration++)
    11101140                {                       
    … …  
    11121142                }
    11131143               
    1114                 solveGroupCacheFriendlySplitImpulseIterations(bodies ,numBodies,manifoldPtr, numManifolds,constraints,numConstraints,infoGlobal,debugDrawer,stackAlloc);
    11151144        }
    11161145        return 0.f;
    … …  
    11431172                const btSolverConstraint& solverConstr = m_tmpSolverNonContactConstraintPool[j];
    11441173                btTypedConstraint* constr = (btTypedConstraint*)solverConstr.m_originalContactPoint;
    1145                 btScalar sum = constr->internalGetAppliedImpulse();
    1146                 sum += solverConstr.m_appliedImpulse;
    1147                 constr->internalSetAppliedImpulse(sum);
     1174                constr->internalSetAppliedImpulse(solverConstr.m_appliedImpulse);
     1175                if (solverConstr.m_appliedImpulse>constr->getBreakingImpulseThreshold())
     1176                {
     1177                        constr->setEnabled(false);
     1178                }
    11481179        }
    11491180

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
    17 #define SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
     16#ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
     17#define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
    1818
    1919#include "btConstraintSolver.h"
    … …  
    125125
    126126
    127 #endif //SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
     127#endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H
    128128

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

    r8351 r8393  
    2323*/
    2424
    25 #ifndef SLIDER_CONSTRAINT_H
    26 #define SLIDER_CONSTRAINT_H
     25#ifndef BT_SLIDER_CONSTRAINT_H
     26#define BT_SLIDER_CONSTRAINT_H
    2727
    2828
    … …  
    237237        void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
    238238        btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; }
    239         btScalar getLinearPos() { return m_linPos; }
     239
     240        btScalar getLinearPos() const { return m_linPos; }
     241        btScalar getAngularPos() const { return m_angPos; }
     242       
    240243       
    241244
    … …  
    256259        void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
    257260
     261        void setFrames(const btTransform& frameA, const btTransform& frameB)
     262        {
     263                m_frameInA=frameA;
     264                m_frameInB=frameB;
     265                calculateTransforms(m_rbA.getCenterOfMassTransform(),m_rbB.getCenterOfMassTransform());
     266                buildJacobian();
     267        }
     268
     269
    258270        ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
    259271        ///If no axis is provided, it uses the default axis for this constraint.
    … …  
    318330
    319331
    320 #endif //SLIDER_CONSTRAINT_H
    321 
     332#endif //BT_SLIDER_CONSTRAINT_H
     333

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

    r5781 r8393  
    1414*/
    1515
    16 #ifndef SOLVE_2LINEAR_CONSTRAINT_H
    17 #define SOLVE_2LINEAR_CONSTRAINT_H
     16#ifndef BT_SOLVE_2LINEAR_CONSTRAINT_H
     17#define BT_SOLVE_2LINEAR_CONSTRAINT_H
    1818
    1919#include "LinearMath/btMatrix3x3.h"
    … …  
    105105};
    106106
    107 #endif //SOLVE_2LINEAR_CONSTRAINT_H
     107#endif //BT_SOLVE_2LINEAR_CONSTRAINT_H

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

    r8351 r8393  
    3030m_rbB(getFixedBody()),
    3131m_appliedImpulse(btScalar(0.)),
    32 m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE)
     32m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE),
     33m_breakingImpulseThreshold(SIMD_INFINITY),
     34m_isEnabled(true)
    3335{
    3436}
    … …  
    4345m_rbB(rbB),
    4446m_appliedImpulse(btScalar(0.)),
    45 m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE)
     47m_dbgDrawSize(DEFAULT_DEBUGDRAW_SIZE),
     48m_breakingImpulseThreshold(SIMD_INFINITY),
     49m_isEnabled(true)
    4650{
    4751}
    … …  
    141145}
    142146
     147
     148void btAngularLimit::set(btScalar low, btScalar high, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor)
     149{
     150        m_halfRange = (high - low) / 2.0f;
     151        m_center = btNormalizeAngle(low + m_halfRange);
     152        m_softness =  _softness;
     153        m_biasFactor = _biasFactor;
     154        m_relaxationFactor = _relaxationFactor;
     155}
     156
     157void btAngularLimit::test(const btScalar angle)
     158{
     159        m_correction = 0.0f;
     160        m_sign = 0.0f;
     161        m_solveLimit = false;
     162
     163        if (m_halfRange >= 0.0f)
     164        {
     165                btScalar deviation = btNormalizeAngle(angle - m_center);
     166                if (deviation < -m_halfRange)
     167                {
     168                        m_solveLimit = true;
     169                        m_correction = - (deviation + m_halfRange);
     170                        m_sign = +1.0f;
     171                }
     172                else if (deviation > m_halfRange)
     173                {
     174                        m_solveLimit = true;
     175                        m_correction = m_halfRange - deviation;
     176                        m_sign = -1.0f;
     177                }
     178        }
     179}
     180
     181
     182btScalar btAngularLimit::getError() const
     183{
     184        return m_correction * m_sign;
     185}
     186
     187void btAngularLimit::fit(btScalar& angle) const
     188{
     189        if (m_halfRange > 0.0f)
     190        {
     191                btScalar relativeAngle = btNormalizeAngle(angle - m_center);
     192                if (!btEqual(relativeAngle, m_halfRange))
     193                {
     194                        if (relativeAngle > 0.0f)
     195                        {
     196                                angle = getHigh();
     197                        }
     198                        else
     199                        {
     200                                angle = getLow();
     201                        }
     202                }
     203        }
     204}
     205
     206btScalar btAngularLimit::getLow() const
     207{
     208        return btNormalizeAngle(m_center - m_halfRange);
     209}
     210
     211btScalar btAngularLimit::getHigh() const
     212{
     213        return btNormalizeAngle(m_center + m_halfRange);
     214}

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef TYPED_CONSTRAINT_H
    17 #define TYPED_CONSTRAINT_H
     16#ifndef BT_TYPED_CONSTRAINT_H
     17#define BT_TYPED_CONSTRAINT_H
    1818
    1919class btRigidBody;
    2020#include "LinearMath/btScalar.h"
    2121#include "btSolverConstraint.h"
    22 #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
    2322
    2423class btSerializer;
    2524
     25//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility
    2626enum btTypedConstraintType
    2727{
    28         POINT2POINT_CONSTRAINT_TYPE=MAX_CONTACT_MANIFOLD_TYPE+1,
     28        POINT2POINT_CONSTRAINT_TYPE=3,
    2929        HINGE_CONSTRAINT_TYPE,
    3030        CONETWIST_CONSTRAINT_TYPE,
    3131        D6_CONSTRAINT_TYPE,
    3232        SLIDER_CONSTRAINT_TYPE,
    33         CONTACT_CONSTRAINT_TYPE
     33        CONTACT_CONSTRAINT_TYPE,
     34        D6_SPRING_CONSTRAINT_TYPE,
     35        MAX_CONSTRAINT_TYPE
    3436};
    3537
    … …  
    6062                void* m_userConstraintPtr;
    6163        };
     64
     65        btScalar        m_breakingImpulseThreshold;
     66        bool            m_isEnabled;
     67
    6268
    6369        bool m_needsFeedback;
    … …  
    154160        }
    155161
     162
     163        btScalar        getBreakingImpulseThreshold() const
     164        {
     165                return  m_breakingImpulseThreshold;
     166        }
     167
     168        void    setBreakingImpulseThreshold(btScalar threshold)
     169        {
     170                m_breakingImpulseThreshold = threshold;
     171        }
     172
     173        bool    isEnabled() const
     174        {
     175                return m_isEnabled;
     176        }
     177
     178        void    setEnabled(bool enabled)
     179        {
     180                m_isEnabled=enabled;
     181        }
     182
     183
    156184        ///internal method used by the constraint solver, don't use them directly
    157185        virtual void    solveConstraintObsolete(btRigidBody& /*bodyA*/,btRigidBody& /*bodyB*/,btScalar  /*timeStep*/) {};
    … …  
    312340
    313341
    314 
    315 #endif //TYPED_CONSTRAINT_H
     342class btAngularLimit
     343{
     344private:
     345        btScalar
     346                m_center,
     347                m_halfRange,
     348                m_softness,
     349                m_biasFactor,
     350                m_relaxationFactor,
     351                m_correction,
     352                m_sign;
     353
     354        bool
     355                m_solveLimit;
     356
     357public:
     358        /// Default constructor initializes limit as inactive, allowing free constraint movement
     359        btAngularLimit()
     360                :m_center(0.0f),
     361                m_halfRange(-1.0f),
     362                m_softness(0.9f),
     363                m_biasFactor(0.3f),
     364                m_relaxationFactor(1.0f),
     365                m_correction(0.0f),
     366                m_sign(0.0f),
     367                m_solveLimit(false)
     368        {}
     369
     370        /// Sets all limit's parameters.
     371        /// When low > high limit becomes inactive.
     372        /// When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit
     373        void set(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f);
     374
     375        /// Checks conastaint angle against limit. If limit is active and the angle violates the limit
     376        /// correction is calculated.
     377        void test(const btScalar angle);
     378
     379        /// Returns limit's softness
     380        inline btScalar getSoftness() const
     381        {
     382                return m_softness;
     383        }
     384
     385        /// Returns limit's bias factor
     386        inline btScalar getBiasFactor() const
     387        {
     388                return m_biasFactor;
     389        }
     390
     391        /// Returns limit's relaxation factor
     392        inline btScalar getRelaxationFactor() const
     393        {
     394                return m_relaxationFactor;
     395        }
     396
     397        /// Returns correction value evaluated when test() was invoked
     398        inline btScalar getCorrection() const
     399        {
     400                return m_correction;
     401        }
     402
     403        /// Returns sign value evaluated when test() was invoked
     404        inline btScalar getSign() const
     405        {
     406                return m_sign;
     407        }
     408
     409        /// Gives half of the distance between min and max limit angle
     410        inline btScalar getHalfRange() const
     411        {
     412                return m_halfRange;
     413        }
     414
     415        /// Returns true when the last test() invocation recognized limit violation
     416        inline bool isLimit() const
     417        {
     418                return m_solveLimit;
     419        }
     420
     421        /// Checks given angle against limit. If limit is active and angle doesn't fit it, the angle
     422        /// returned is modified so it equals to the limit closest to given angle.
     423        void fit(btScalar& angle) const;
     424
     425        /// Returns correction value multiplied by sign value
     426        btScalar getError() const;
     427
     428        btScalar getLow() const;
     429
     430        btScalar getHigh() const;
     431
     432};
     433
     434
     435
     436#endif //BT_TYPED_CONSTRAINT_H

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

    r8351 r8393  
    6262}
    6363
     64void btUniversalConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
     65{
     66  m_axis1 = axis1;
     67  m_axis2 = axis2;
     68
     69        btVector3 zAxis = axis1.normalized();
     70        btVector3 yAxis = axis2.normalized();
     71        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
     72
     73        btTransform frameInW;
     74        frameInW.setIdentity();
     75        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
     76                                xAxis[1], yAxis[1], zAxis[1],
     77                                xAxis[2], yAxis[2], zAxis[2]);
     78        frameInW.setOrigin(m_anchor);
     79
     80        // now get constraint frame in local coordinate systems
     81        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
     82        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
     83
     84  calculateTransforms();
     85}
     86
     87

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

    r8351 r8393  
    1414*/
    1515
    16 #ifndef UNIVERSAL_CONSTRAINT_H
    17 #define UNIVERSAL_CONSTRAINT_H
     16#ifndef BT_UNIVERSAL_CONSTRAINT_H
     17#define BT_UNIVERSAL_CONSTRAINT_H
    1818
    1919
    … …  
    5353        void setUpperLimit(btScalar ang1max, btScalar ang2max) { setAngularUpperLimit(btVector3(0.f, ang1max, ang2max)); }
    5454        void setLowerLimit(btScalar ang1min, btScalar ang2min) { setAngularLowerLimit(btVector3(0.f, ang1min, ang2min)); }
     55
     56        void setAxis( const btVector3& axis1, const btVector3& axis2);
    5557};
    5658
    5759
    5860
    59 #endif // UNIVERSAL_CONSTRAINT_H
     61#endif // BT_UNIVERSAL_CONSTRAINT_H
    6062
Note: See TracChangeset for help on using the changeset viewer.