← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to extern/bullet2/src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/bullet2/src/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp
37
37
btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, const btVector3& pivotInA,const btVector3& pivotInB,
38
38
                                                                         const btVector3& axisInA,const btVector3& axisInB, bool useReferenceFrameA)
39
39
                                                                         :btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),
 
40
#ifdef _BT_USE_CENTER_LIMIT_
 
41
                                                                         m_limit(),
 
42
#endif
40
43
                                                                         m_angularOnly(false),
41
44
                                                                         m_enableAngularMotor(false),
42
45
                                                                         m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
43
46
                                                                         m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET),
44
47
                                                                         m_useReferenceFrameA(useReferenceFrameA),
45
48
                                                                         m_flags(0)
46
 
#ifdef _BT_USE_CENTER_LIMIT_
47
 
                                                                        ,m_limit()
48
 
#endif
49
49
{
50
50
        m_rbAFrame.getOrigin() = pivotInA;
51
51
        
93
93
 
94
94
 
95
95
btHingeConstraint::btHingeConstraint(btRigidBody& rbA,const btVector3& pivotInA,const btVector3& axisInA, bool useReferenceFrameA)
96
 
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA), m_angularOnly(false), m_enableAngularMotor(false), 
 
96
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA),
 
97
#ifdef _BT_USE_CENTER_LIMIT_
 
98
m_limit(),
 
99
#endif
 
100
m_angularOnly(false), m_enableAngularMotor(false), 
97
101
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
98
102
m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET),
99
103
m_useReferenceFrameA(useReferenceFrameA),
100
104
m_flags(0)
101
 
#ifdef  _BT_USE_CENTER_LIMIT_
102
 
,m_limit()
103
 
#endif
104
105
{
105
106
 
106
107
        // since no frame is given, assume this to be zero angle and just pick rb transform axis
142
143
btHingeConstraint::btHingeConstraint(btRigidBody& rbA,btRigidBody& rbB, 
143
144
                                                                     const btTransform& rbAFrame, const btTransform& rbBFrame, bool useReferenceFrameA)
144
145
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA,rbB),m_rbAFrame(rbAFrame),m_rbBFrame(rbBFrame),
 
146
#ifdef _BT_USE_CENTER_LIMIT_
 
147
m_limit(),
 
148
#endif
145
149
m_angularOnly(false),
146
150
m_enableAngularMotor(false),
147
151
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
148
152
m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET),
149
153
m_useReferenceFrameA(useReferenceFrameA),
150
154
m_flags(0)
151
 
#ifdef  _BT_USE_CENTER_LIMIT_
152
 
,m_limit()
153
 
#endif
154
155
{
155
156
#ifndef _BT_USE_CENTER_LIMIT_
156
157
        //start with free
168
169
 
169
170
btHingeConstraint::btHingeConstraint(btRigidBody& rbA, const btTransform& rbAFrame, bool useReferenceFrameA)
170
171
:btTypedConstraint(HINGE_CONSTRAINT_TYPE, rbA),m_rbAFrame(rbAFrame),m_rbBFrame(rbAFrame),
 
172
#ifdef _BT_USE_CENTER_LIMIT_
 
173
m_limit(),
 
174
#endif
171
175
m_angularOnly(false),
172
176
m_enableAngularMotor(false),
173
177
m_useSolveConstraintObsolete(HINGE_USE_OBSOLETE_SOLVER),
174
178
m_useOffsetForConstraintFrame(HINGE_USE_FRAME_OFFSET),
175
179
m_useReferenceFrameA(useReferenceFrameA),
176
180
m_flags(0)
177
 
#ifdef  _BT_USE_CENTER_LIMIT_
178
 
,m_limit()
179
 
#endif
180
181
{
181
182
        ///not providing rigidbody B means implicitly using worldspace for body B
182
183
 
663
664
        btScalar targetAngle = qHinge.getAngle();
664
665
        if (targetAngle > SIMD_PI) // long way around. flip quat and recalculate.
665
666
        {
666
 
                qHinge = operator-(qHinge);
 
667
                qHinge = -(qHinge);
667
668
                targetAngle = qHinge.getAngle();
668
669
        }
669
670
        if (qHinge.getZ() < 0)