Changeset 8351 for code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.h

Timestamp:

Apr 28, 2011, 7:15:14 AM (13 years ago)

Author:

rgrieder

Message:

Merged kicklib2 branch back to trunk (includes former branches ois_update, mac_osx and kicklib).

Notes for updating

Linux:
You don't need an extra package for CEGUILua and Tolua, it's already shipped with CEGUI.
However you do need to make sure that the OgreRenderer is installed too with CEGUI 0.7 (may be a separate package).
Also, Orxonox now recognises if you install the CgProgramManager (a separate package available on newer Ubuntu on Debian systems).

Windows:
Download the new dependency packages versioned 6.0 and use these. If you have problems with that or if you don't like the in game console problem mentioned below, you can download the new 4.3 version of the packages (only available for Visual Studio 2005/2008).

Key new features:

• *Support for Mac OS X*
• Visual Studio 2010 support
• Bullet library update to 2.77
• OIS library update to 1.3
• Support for CEGUI 0.7 —> Support for Arch Linux and even SuSE
• Improved install target
• Compiles now with GCC 4.6
• Ogre Cg Shader plugin activated for Linux if available
• And of course lots of bug fixes

There are also some regressions:

• No support for CEGUI 0.5, Ogre 1.4 and boost 1.35 - 1.39 any more
• In game console is not working in main menu for CEGUI 0.7
• Tolua (just the C lib, not the application) and CEGUILua libraries are no longer in our repository. —> You will need to get these as well when compiling Orxonox
• And of course lots of new bugs we don't yet know about

File:

• code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btTypedConstraint.h (modified) (8 diffs)

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

@@ -1 +1 @@
 /*
 Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
+Copyright (c) 2003-2010 Erwin Coumans  http://continuousphysics.com/Bullet/
 
 This software is provided 'as-is', without any express or implied warranty.
@@ -20 +20 @@
 #include "LinearMath/btScalar.h"
 #include "btSolverConstraint.h"
-struct  btSolverBody;
-
-
-
+#include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h"
+
+class btSerializer;
 
 enum btTypedConstraintType
 {
-        POINT2POINT_CONSTRAINT_TYPE,
+        POINT2POINT_CONSTRAINT_TYPE=MAX_CONTACT_MANIFOLD_TYPE+1,
         HINGE_CONSTRAINT_TYPE,
         CONETWIST_CONSTRAINT_TYPE,
         D6_CONSTRAINT_TYPE,
-        SLIDER_CONSTRAINT_TYPE
+        SLIDER_CONSTRAINT_TYPE,
+        CONTACT_CONSTRAINT_TYPE
 };
 
+
+enum btConstraintParams
+{
+        BT_CONSTRAINT_ERP=1,
+        BT_CONSTRAINT_STOP_ERP,
+        BT_CONSTRAINT_CFM,
+        BT_CONSTRAINT_STOP_CFM
+};
+
+#if 1
+        #define btAssertConstrParams(_par) btAssert(_par) 
+#else
+        #define btAssertConstrParams(_par)
+#endif
+
+
 ///TypedConstraint is the baseclass for Bullet constraints and vehicles
-class btTypedConstraint
+class btTypedConstraint : public btTypedObject
 {
         int     m_userConstraintType;
-        int     m_userConstraintId;
-
-        btTypedConstraintType m_constraintType;
+
+        union
+        {
+                int     m_userConstraintId;
+                void* m_userConstraintPtr;
+        };
+
+        bool m_needsFeedback;
 
         btTypedConstraint&      operator=(btTypedConstraint&    other)
@@ -55 +76 @@
         btScalar        m_dbgDrawSize;
 
+        ///internal method used by the constraint solver, don't use them directly
+        btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact);
+        
+        static btRigidBody& getFixedBody();
 
 public:
 
-        btTypedConstraint(btTypedConstraintType type);
         virtual ~btTypedConstraint() {};
         btTypedConstraint(btTypedConstraintType type, btRigidBody& rbA);
@@ -94 +118 @@
                 // the constraint.
                 int *findex;
+                // number of solver iterations
+                int m_numIterations;
+
+                //damping of the velocity
+                btScalar        m_damping;
         };
 
-
-        virtual void    buildJacobian() = 0;
-
+        ///internal method used by the constraint solver, don't use them directly
+        virtual void    buildJacobian() {};
+
+        ///internal method used by the constraint solver, don't use them directly
         virtual void    setupSolverConstraint(btConstraintArray& ca, int solverBodyA,int solverBodyB, btScalar timeStep)
         {
-        }
+        (void)ca;
+        (void)solverBodyA;
+        (void)solverBodyB;
+        (void)timeStep;
+        }
+        
+        ///internal method used by the constraint solver, don't use them directly
         virtual void getInfo1 (btConstraintInfo1* info)=0;
 
+        ///internal method used by the constraint solver, don't use them directly
         virtual void getInfo2 (btConstraintInfo2* info)=0;
 
-        virtual void    solveConstraintObsolete(btSolverBody& bodyA,btSolverBody& bodyB,btScalar        timeStep) = 0;
-
-        btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact);
+        ///internal method used by the constraint solver, don't use them directly
+        void    internalSetAppliedImpulse(btScalar appliedImpulse)
+        {
+                m_appliedImpulse = appliedImpulse;
+        }
+        ///internal method used by the constraint solver, don't use them directly
+        btScalar        internalGetAppliedImpulse()
+        {
+                return m_appliedImpulse;
+        }
+
+        ///internal method used by the constraint solver, don't use them directly
+        virtual void    solveConstraintObsolete(btRigidBody& /*bodyA*/,btRigidBody& /*bodyB*/,btScalar  /*timeStep*/) {};
+
         
         const btRigidBody& getRigidBodyA() const
@@ -148 +196 @@
         }
 
+        void    setUserConstraintPtr(void* ptr)
+        {
+                m_userConstraintPtr = ptr;
+        }
+
+        void*   getUserConstraintPtr()
+        {
+                return m_userConstraintPtr;
+        }
+
         int getUid() const
         {
@@ -153 +211 @@
         } 
 
+        bool    needsFeedback() const
+        {
+                return m_needsFeedback;
+        }
+
+        ///enableFeedback will allow to read the applied linear and angular impulse
+        ///use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information
+        void    enableFeedback(bool needsFeedback)
+        {
+                m_needsFeedback = needsFeedback;
+        }
+
+        ///getAppliedImpulse is an estimated total applied impulse. 
+        ///This feedback could be used to determine breaking constraints or playing sounds.
         btScalar        getAppliedImpulse() const
         {
+                btAssert(m_needsFeedback);
                 return m_appliedImpulse;
         }
@@ -160 +233 @@
         btTypedConstraintType getConstraintType () const
         {
-                return m_constraintType;
+                return btTypedConstraintType(m_objectType);
         }
         
@@ -171 +244 @@
                 return m_dbgDrawSize;
         }
-        
+
+        ///override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). 
+        ///If no axis is provided, it uses the default axis for this constraint.
+        virtual void    setParam(int num, btScalar value, int axis = -1) = 0;
+
+        ///return the local value of parameter
+        virtual btScalar getParam(int num, int axis = -1) const = 0;
+        
+        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;
+
 };
 
+// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits 
+// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI])
+SIMD_FORCE_INLINE btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
+{
+        if(angleLowerLimitInRadians >= angleUpperLimitInRadians)
+        {
+                return angleInRadians;
+        }
+        else if(angleInRadians < angleLowerLimitInRadians)
+        {
+                btScalar diffLo = btFabs(btNormalizeAngle(angleLowerLimitInRadians - angleInRadians));
+                btScalar diffHi = btFabs(btNormalizeAngle(angleUpperLimitInRadians - angleInRadians));
+                return (diffLo < diffHi) ? angleInRadians : (angleInRadians + SIMD_2_PI);
+        }
+        else if(angleInRadians > angleUpperLimitInRadians)
+        {
+                btScalar diffHi = btFabs(btNormalizeAngle(angleInRadians - angleUpperLimitInRadians));
+                btScalar diffLo = btFabs(btNormalizeAngle(angleInRadians - angleLowerLimitInRadians));
+                return (diffLo < diffHi) ? (angleInRadians - SIMD_2_PI) : angleInRadians;
+        }
+        else
+        {
+                return angleInRadians;
+        }
+}
+
+///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
+struct  btTypedConstraintData
+{
+        btRigidBodyData         *m_rbA;
+        btRigidBodyData         *m_rbB;
+        char    *m_name;
+
+        int     m_objectType;
+        int     m_userConstraintType;
+        int     m_userConstraintId;
+        int     m_needsFeedback;
+
+        float   m_appliedImpulse;
+        float   m_dbgDrawSize;
+
+        int     m_disableCollisionsBetweenLinkedBodies;
+        char    m_pad4[4];
+        
+};
+
+SIMD_FORCE_INLINE       int     btTypedConstraint::calculateSerializeBufferSize() const
+{
+        return sizeof(btTypedConstraintData);
+}
+
+
+
+
 #endif //TYPED_CONSTRAINT_H