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

Timestamp:

May 3, 2011, 5:07:42 AM (13 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.

File:

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

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