Bullet Collision Detection & Physics Library: btGeneric6DofSpring2Constraint.h Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btGeneric6DofSpring2Constraint.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
4
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10
11 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15
16 /*
17 2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer
18 Pros:
19 - Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled)
20 - Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring)
21 - Servo motor functionality
22 - Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision)
23 - Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2)
24
25 Cons:
26 - It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation.
27 - At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.)
28 */
29
32
33 /*
34 2007-09-09
35 btGeneric6DofConstraint Refactored by Francisco Le?n
36 email: projectileman@yahoo.com
37 http://gimpact.sf.net
38 */
39
40
41 #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H
42 #define BT_GENERIC_6DOF_CONSTRAINT2_H
43
44 #include "LinearMath/btVector3.h"
45 #include "btJacobianEntry.h"
46 #include "btTypedConstraint.h"
47
48 class btRigidBody;
49
50
51 #ifdef BT_USE_DOUBLE_PRECISION
52 #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintDoubleData2
53 #define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintDoubleData2"
54 #else
55 #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData
56 #define btGeneric6DofSpring2ConstraintDataName "btGeneric6DofSpring2ConstraintData"
57 #endif //BT_USE_DOUBLE_PRECISION
58
59 enum RotateOrder
60 {
61 RO_XYZ=0,
62 RO_XZY,
63 RO_YXZ,
64 RO_YZX,
65 RO_ZXY,
66 RO_ZYX
67 };
68
69 class btRotationalLimitMotor2
70 {
71 public:
72 // upper < lower means free
73 // upper == lower means locked
74 // upper > lower means limited
75 btScalar m_loLimit;
76 btScalar m_hiLimit;
77 btScalar m_bounce;
78 btScalar m_stopERP;
79 btScalar m_stopCFM;
80 btScalar m_motorERP;
81 btScalar m_motorCFM;
82 bool m_enableMotor;
83 btScalar m_targetVelocity;
84 btScalar m_maxMotorForce;
85 bool m_servoMotor;
86 btScalar m_servoTarget;
87 bool m_enableSpring;
88 btScalar m_springStiffness;
89 bool m_springStiffnessLimited;
90 btScalar m_springDamping;
91 bool m_springDampingLimited;
92 btScalar m_equilibriumPoint;
93
94 btScalar m_currentLimitError;
95 btScalar m_currentLimitErrorHi;
96 btScalar m_currentPosition;
97 int m_currentLimit;
98
99 btRotationalLimitMotor2()
100 {
101 m_loLimit = 1.0f;
102 m_hiLimit = -1.0f;
103 m_bounce = 0.0f;
104 m_stopERP = 0.2f;
105 m_stopCFM = 0.f;
106 m_motorERP = 0.9f;
107 m_motorCFM = 0.f;
108 m_enableMotor = false;
109 m_targetVelocity = 0;
110 m_maxMotorForce = 0.1f;
111 m_servoMotor = false;
112 m_servoTarget = 0;
113 m_enableSpring = false;
114 m_springStiffness = 0;
115 m_springStiffnessLimited = false;
116 m_springDamping = 0;
117 m_springDampingLimited = false;
118 m_equilibriumPoint = 0;
119
120 m_currentLimitError = 0;
121 m_currentLimitErrorHi = 0;
122 m_currentPosition = 0;
123 m_currentLimit = 0;
124 }
125
126 btRotationalLimitMotor2(const btRotationalLimitMotor2 & limot)
127 {
128 m_loLimit = limot.m_loLimit;
129 m_hiLimit = limot.m_hiLimit;
130 m_bounce = limot.m_bounce;
131 m_stopERP = limot.m_stopERP;
132 m_stopCFM = limot.m_stopCFM;
133 m_motorERP = limot.m_motorERP;
134 m_motorCFM = limot.m_motorCFM;
135 m_enableMotor = limot.m_enableMotor;
136 m_targetVelocity = limot.m_targetVelocity;
137 m_maxMotorForce = limot.m_maxMotorForce;
138 m_servoMotor = limot.m_servoMotor;
139 m_servoTarget = limot.m_servoTarget;
140 m_enableSpring = limot.m_enableSpring;
141 m_springStiffness = limot.m_springStiffness;
142 m_springStiffnessLimited = limot.m_springStiffnessLimited;
143 m_springDamping = limot.m_springDamping;
144 m_springDampingLimited = limot.m_springDampingLimited;
145 m_equilibriumPoint = limot.m_equilibriumPoint;
146
147 m_currentLimitError = limot.m_currentLimitError;
148 m_currentLimitErrorHi = limot.m_currentLimitErrorHi;
149 m_currentPosition = limot.m_currentPosition;
150 m_currentLimit = limot.m_currentLimit;
151 }
152
153
154 bool isLimited()
155 {
156 if(m_loLimit > m_hiLimit) return false;
157 return true;
158 }
159
160 void testLimitValue(btScalar test_value);
161 };
162
163
164
165 class btTranslationalLimitMotor2
166 {
167 public:
168 // upper < lower means free
169 // upper == lower means locked
170 // upper > lower means limited
171 btVector3 m_lowerLimit;
172 btVector3 m_upperLimit;
173 btVector3 m_bounce;
174 btVector3 m_stopERP;
175 btVector3 m_stopCFM;
176 btVector3 m_motorERP;
177 btVector3 m_motorCFM;
178 bool m_enableMotor[3];
179 bool m_servoMotor[3];
180 bool m_enableSpring[3];
181 btVector3 m_servoTarget;
182 btVector3 m_springStiffness;
183 bool m_springStiffnessLimited[3];
184 btVector3 m_springDamping;
185 bool m_springDampingLimited[3];
186 btVector3 m_equilibriumPoint;
187 btVector3 m_targetVelocity;
188 btVector3 m_maxMotorForce;
189
190 btVector3 m_currentLimitError;
191 btVector3 m_currentLimitErrorHi;
192 btVector3 m_currentLinearDiff;
193 int m_currentLimit[3];
194
195 btTranslationalLimitMotor2()
196 {
197 m_lowerLimit .setValue(0.f , 0.f , 0.f );
198 m_upperLimit .setValue(0.f , 0.f , 0.f );
199 m_bounce .setValue(0.f , 0.f , 0.f );
200 m_stopERP .setValue(0.2f, 0.2f, 0.2f);
201 m_stopCFM .setValue(0.f , 0.f , 0.f );
202 m_motorERP .setValue(0.9f, 0.9f, 0.9f);
203 m_motorCFM .setValue(0.f , 0.f , 0.f );
204
205 m_currentLimitError .setValue(0.f , 0.f , 0.f );
206 m_currentLimitErrorHi.setValue(0.f , 0.f , 0.f );
207 m_currentLinearDiff .setValue(0.f , 0.f , 0.f );
208
209 for(int i=0; i < 3; i++)
210 {
211 m_enableMotor[i] = false;
212 m_servoMotor[i] = false;
213 m_enableSpring[i] = false;
214 m_servoTarget[i] = btScalar(0.f);
215 m_springStiffness[i] = btScalar(0.f);
216 m_springStiffnessLimited[i] = false;
217 m_springDamping[i] = btScalar(0.f);
218 m_springDampingLimited[i] = false;
219 m_equilibriumPoint[i] = btScalar(0.f);
220 m_targetVelocity[i] = btScalar(0.f);
221 m_maxMotorForce[i] = btScalar(0.f);
222
223 m_currentLimit[i] = 0;
224 }
225 }
226
227 btTranslationalLimitMotor2(const btTranslationalLimitMotor2 & other )
228 {
229 m_lowerLimit = other.m_lowerLimit;
230 m_upperLimit = other.m_upperLimit;
231 m_bounce = other.m_bounce;
232 m_stopERP = other.m_stopERP;
233 m_stopCFM = other.m_stopCFM;
234 m_motorERP = other.m_motorERP;
235 m_motorCFM = other.m_motorCFM;
236
237 m_currentLimitError = other.m_currentLimitError;
238 m_currentLimitErrorHi = other.m_currentLimitErrorHi;
239 m_currentLinearDiff = other.m_currentLinearDiff;
240
241 for(int i=0; i < 3; i++)
242 {
243 m_enableMotor[i] = other.m_enableMotor[i];
244 m_servoMotor[i] = other.m_servoMotor[i];
245 m_enableSpring[i] = other.m_enableSpring[i];
246 m_servoTarget[i] = other.m_servoTarget[i];
247 m_springStiffness[i] = other.m_springStiffness[i];
248 m_springStiffnessLimited[i] = other.m_springStiffnessLimited[i];
249 m_springDamping[i] = other.m_springDamping[i];
250 m_springDampingLimited[i] = other.m_springDampingLimited[i];
251 m_equilibriumPoint[i] = other.m_equilibriumPoint[i];
252 m_targetVelocity[i] = other.m_targetVelocity[i];
253 m_maxMotorForce[i] = other.m_maxMotorForce[i];
254
255 m_currentLimit[i] = other.m_currentLimit[i];
256 }
257 }
258
259 inline bool isLimited(int limitIndex)
260 {
261 return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
262 }
263
264 void testLimitValue(int limitIndex, btScalar test_value);
265 };
266
267 enum bt6DofFlags2
268 {
269 BT_6DOF_FLAGS_CFM_STOP2 = 1,
270 BT_6DOF_FLAGS_ERP_STOP2 = 2,
271 BT_6DOF_FLAGS_CFM_MOTO2 = 4,
272 BT_6DOF_FLAGS_ERP_MOTO2 = 8
273 };
274 #define BT_6DOF_FLAGS_AXIS_SHIFT2 4 // bits per axis
275
276
277 ATTRIBUTE_ALIGNED16(class) btGeneric6DofSpring2Constraint : public btTypedConstraint
278 {
279 protected:
280
281 btTransform m_frameInA;
282 btTransform m_frameInB;
283
284 btJacobianEntry m_jacLinear[3];
285 btJacobianEntry m_jacAng[3];
286
287 btTranslationalLimitMotor2 m_linearLimits;
288 btRotationalLimitMotor2 m_angularLimits[3];
289
290 RotateOrder m_rotateOrder;
291
292 protected:
293
294 btTransform m_calculatedTransformA;
295 btTransform m_calculatedTransformB;
296 btVector3 m_calculatedAxisAngleDiff;
297 btVector3 m_calculatedAxis[3];
298 btVector3 m_calculatedLinearDiff;
299 btScalar m_factA;
300 btScalar m_factB;
301 bool m_hasStaticBody;
302 int m_flags;
303
304 btGeneric6DofSpring2Constraint& operator=(btGeneric6DofSpring2Constraint&)
305 {
306 btAssert(0);
307 return *this;
308 }
309
310 int setAngularLimits(btConstraintInfo2 *info, int row_offset,const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);
311 int setLinearLimits(btConstraintInfo2 *info, int row, const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);
312
313 void calculateLinearInfo();
314 void calculateAngleInfo();
315 void testAngularLimitMotor(int axis_index);
316
317 void calculateJacobi(btRotationalLimitMotor2* limot, const btTransform& transA,const btTransform& transB, btConstraintInfo2* info, int srow, btVector3& ax1, int rotational, int rotAllowed);
318 int get_limit_motor_info2(btRotationalLimitMotor2* limot,
319 const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB,
320 btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false);
321
322 static btScalar btGetMatrixElem(const btMatrix3x3& mat, int index);
323 static bool matrixToEulerXYZ(const btMatrix3x3& mat,btVector3& xyz);
324 static bool matrixToEulerXZY(const btMatrix3x3& mat,btVector3& xyz);
325 static bool matrixToEulerYXZ(const btMatrix3x3& mat,btVector3& xyz);
326 static bool matrixToEulerYZX(const btMatrix3x3& mat,btVector3& xyz);
327 static bool matrixToEulerZXY(const btMatrix3x3& mat,btVector3& xyz);
328 static bool matrixToEulerZYX(const btMatrix3x3& mat,btVector3& xyz);
329
330 public:
331
332 BT_DECLARE_ALIGNED_ALLOCATOR();
333
334 btGeneric6DofSpring2Constraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ);
335 btGeneric6DofSpring2Constraint(btRigidBody& rbB, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ);
336
337 virtual void buildJacobian() {}
338 virtual void getInfo1 (btConstraintInfo1* info);
339 virtual void getInfo2 (btConstraintInfo2* info);
340 virtual int calculateSerializeBufferSize() const;
341 virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
342
343 btRotationalLimitMotor2* getRotationalLimitMotor(int index) { return &m_angularLimits[index]; }
344 btTranslationalLimitMotor2* getTranslationalLimitMotor() { return &m_linearLimits; }
345
346 // Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies.
347 void calculateTransforms(const btTransform& transA,const btTransform& transB);
348 void calculateTransforms();
349
350 // Gets the global transform of the offset for body A
351 const btTransform & getCalculatedTransformA() const { return m_calculatedTransformA; }
352 // Gets the global transform of the offset for body B
353 const btTransform & getCalculatedTransformB() const { return m_calculatedTransformB; }
354
355 const btTransform & getFrameOffsetA() const { return m_frameInA; }
356 const btTransform & getFrameOffsetB() const { return m_frameInB; }
357
358 btTransform & getFrameOffsetA() { return m_frameInA; }
359 btTransform & getFrameOffsetB() { return m_frameInB; }
360
361 // Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
362 btVector3 getAxis(int axis_index) const { return m_calculatedAxis[axis_index]; }
363
364 // Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
365 btScalar getAngle(int axis_index) const { return m_calculatedAxisAngleDiff[axis_index]; }
366
367 // Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
368 btScalar getRelativePivotPosition(int axis_index) const { return m_calculatedLinearDiff[axis_index]; }
369
370 void setFrames(const btTransform & frameA, const btTransform & frameB);
371
372 void setLinearLowerLimit(const btVector3& linearLower) { m_linearLimits.m_lowerLimit = linearLower; }
373 void getLinearLowerLimit(btVector3& linearLower) { linearLower = m_linearLimits.m_lowerLimit; }
374 void setLinearUpperLimit(const btVector3& linearUpper) { m_linearLimits.m_upperLimit = linearUpper; }
375 void getLinearUpperLimit(btVector3& linearUpper) { linearUpper = m_linearLimits.m_upperLimit; }
376
377 void setAngularLowerLimit(const btVector3& angularLower)
378 {
379 for(int i = 0; i < 3; i++)
380 m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]);
381 }
382
383 void setAngularLowerLimitReversed(const btVector3& angularLower)
384 {
385 for(int i = 0; i < 3; i++)
386 m_angularLimits[i].m_hiLimit = btNormalizeAngle(-angularLower[i]);
387 }
388
389 void getAngularLowerLimit(btVector3& angularLower)
390 {
391 for(int i = 0; i < 3; i++)
392 angularLower[i] = m_angularLimits[i].m_loLimit;
393 }
394
395 void getAngularLowerLimitReversed(btVector3& angularLower)
396 {
397 for(int i = 0; i < 3; i++)
398 angularLower[i] = -m_angularLimits[i].m_hiLimit;
399 }
400
401 void setAngularUpperLimit(const btVector3& angularUpper)
402 {
403 for(int i = 0; i < 3; i++)
404 m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
405 }
406
407 void setAngularUpperLimitReversed(const btVector3& angularUpper)
408 {
409 for(int i = 0; i < 3; i++)
410 m_angularLimits[i].m_loLimit = btNormalizeAngle(-angularUpper[i]);
411 }
412
413 void getAngularUpperLimit(btVector3& angularUpper)
414 {
415 for(int i = 0; i < 3; i++)
416 angularUpper[i] = m_angularLimits[i].m_hiLimit;
417 }
418
419 void getAngularUpperLimitReversed(btVector3& angularUpper)
420 {
421 for(int i = 0; i < 3; i++)
422 angularUpper[i] = -m_angularLimits[i].m_loLimit;
423 }
424
425 //first 3 are linear, next 3 are angular
426
427 void setLimit(int axis, btScalar lo, btScalar hi)
428 {
429 if(axis<3)
430 {
431 m_linearLimits.m_lowerLimit[axis] = lo;
432 m_linearLimits.m_upperLimit[axis] = hi;
433 }
434 else
435 {
436 lo = btNormalizeAngle(lo);
437 hi = btNormalizeAngle(hi);
438 m_angularLimits[axis-3].m_loLimit = lo;
439 m_angularLimits[axis-3].m_hiLimit = hi;
440 }
441 }
442
443 void setLimitReversed(int axis, btScalar lo, btScalar hi)
444 {
445 if(axis<3)
446 {
447 m_linearLimits.m_lowerLimit[axis] = lo;
448 m_linearLimits.m_upperLimit[axis] = hi;
449 }
450 else
451 {
452 lo = btNormalizeAngle(lo);
453 hi = btNormalizeAngle(hi);
454 m_angularLimits[axis-3].m_hiLimit = -lo;
455 m_angularLimits[axis-3].m_loLimit = -hi;
456 }
457 }
458
459 bool isLimited(int limitIndex)
460 {
461 if(limitIndex<3)
462 {
463 return m_linearLimits.isLimited(limitIndex);
464 }
465 return m_angularLimits[limitIndex-3].isLimited();
466 }
467
468 void setRotationOrder(RotateOrder order) { m_rotateOrder = order; }
469 RotateOrder getRotationOrder() { return m_rotateOrder; }
470
471 void setAxis( const btVector3& axis1, const btVector3& axis2);
472
473 void setBounce(int index, btScalar bounce);
474
475 void enableMotor(int index, bool onOff);
476 void setServo(int index, bool onOff); // set the type of the motor (servo or not) (the motor has to be turned on for servo also)
477 void setTargetVelocity(int index, btScalar velocity);
478 void setServoTarget(int index, btScalar target);
479 void setMaxMotorForce(int index, btScalar force);
480
481 void enableSpring(int index, bool onOff);
482 void setStiffness(int index, btScalar stiffness, bool limitIfNeeded = true); // if limitIfNeeded is true the system will automatically limit the stiffness in necessary situations where otherwise the spring would move unrealistically too widely
483 void setDamping(int index, btScalar damping, bool limitIfNeeded = true); // if limitIfNeeded is true the system will automatically limit the damping in necessary situations where otherwise the spring would blow up
484 void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF
485 void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF
486 void setEquilibriumPoint(int index, btScalar val);
487
488 //override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
489 //If no axis is provided, it uses the default axis for this constraint.
490 virtual void setParam(int num, btScalar value, int axis = -1);
491 virtual btScalar getParam(int num, int axis = -1) const;
492 };
493
494
495 struct btGeneric6DofSpring2ConstraintData
496 {
497 btTypedConstraintData m_typeConstraintData;
498 btTransformFloatData m_rbAFrame;
499 btTransformFloatData m_rbBFrame;
500
501 btVector3FloatData m_linearUpperLimit;
502 btVector3FloatData m_linearLowerLimit;
503 btVector3FloatData m_linearBounce;
504 btVector3FloatData m_linearStopERP;
505 btVector3FloatData m_linearStopCFM;
506 btVector3FloatData m_linearMotorERP;
507 btVector3FloatData m_linearMotorCFM;
508 btVector3FloatData m_linearTargetVelocity;
509 btVector3FloatData m_linearMaxMotorForce;
510 btVector3FloatData m_linearServoTarget;
511 btVector3FloatData m_linearSpringStiffness;
512 btVector3FloatData m_linearSpringDamping;
513 btVector3FloatData m_linearEquilibriumPoint;
514 char m_linearEnableMotor[4];
515 char m_linearServoMotor[4];
516 char m_linearEnableSpring[4];
517 char m_linearSpringStiffnessLimited[4];
518 char m_linearSpringDampingLimited[4];
519 char m_padding1[4];
520
521 btVector3FloatData m_angularUpperLimit;
522 btVector3FloatData m_angularLowerLimit;
523 btVector3FloatData m_angularBounce;
524 btVector3FloatData m_angularStopERP;
525 btVector3FloatData m_angularStopCFM;
526 btVector3FloatData m_angularMotorERP;
527 btVector3FloatData m_angularMotorCFM;
528 btVector3FloatData m_angularTargetVelocity;
529 btVector3FloatData m_angularMaxMotorForce;
530 btVector3FloatData m_angularServoTarget;
531 btVector3FloatData m_angularSpringStiffness;
532 btVector3FloatData m_angularSpringDamping;
533 btVector3FloatData m_angularEquilibriumPoint;
534 char m_angularEnableMotor[4];
535 char m_angularServoMotor[4];
536 char m_angularEnableSpring[4];
537 char m_angularSpringStiffnessLimited[4];
538 char m_angularSpringDampingLimited[4];
539
540 int m_rotateOrder;
541 };
542
543 struct btGeneric6DofSpring2ConstraintDoubleData2
544 {
545 btTypedConstraintDoubleData m_typeConstraintData;
546 btTransformDoubleData m_rbAFrame;
547 btTransformDoubleData m_rbBFrame;
548
549 btVector3DoubleData m_linearUpperLimit;
550 btVector3DoubleData m_linearLowerLimit;
551 btVector3DoubleData m_linearBounce;
552 btVector3DoubleData m_linearStopERP;
553 btVector3DoubleData m_linearStopCFM;
554 btVector3DoubleData m_linearMotorERP;
555 btVector3DoubleData m_linearMotorCFM;
556 btVector3DoubleData m_linearTargetVelocity;
557 btVector3DoubleData m_linearMaxMotorForce;
558 btVector3DoubleData m_linearServoTarget;
559 btVector3DoubleData m_linearSpringStiffness;
560 btVector3DoubleData m_linearSpringDamping;
561 btVector3DoubleData m_linearEquilibriumPoint;
562 char m_linearEnableMotor[4];
563 char m_linearServoMotor[4];
564 char m_linearEnableSpring[4];
565 char m_linearSpringStiffnessLimited[4];
566 char m_linearSpringDampingLimited[4];
567 char m_padding1[4];
568
569 btVector3DoubleData m_angularUpperLimit;
570 btVector3DoubleData m_angularLowerLimit;
571 btVector3DoubleData m_angularBounce;
572 btVector3DoubleData m_angularStopERP;
573 btVector3DoubleData m_angularStopCFM;
574 btVector3DoubleData m_angularMotorERP;
575 btVector3DoubleData m_angularMotorCFM;
576 btVector3DoubleData m_angularTargetVelocity;
577 btVector3DoubleData m_angularMaxMotorForce;
578 btVector3DoubleData m_angularServoTarget;
579 btVector3DoubleData m_angularSpringStiffness;
580 btVector3DoubleData m_angularSpringDamping;
581 btVector3DoubleData m_angularEquilibriumPoint;
582 char m_angularEnableMotor[4];
583 char m_angularServoMotor[4];
584 char m_angularEnableSpring[4];
585 char m_angularSpringStiffnessLimited[4];
586 char m_angularSpringDampingLimited[4];
587
588 int m_rotateOrder;
589 };
590
591 SIMD_FORCE_INLINE int btGeneric6DofSpring2Constraint::calculateSerializeBufferSize() const
592 {
593 return sizeof(btGeneric6DofSpring2ConstraintData2);
594 }
595
596 SIMD_FORCE_INLINE const char* btGeneric6DofSpring2Constraint::serialize(void* dataBuffer, btSerializer* serializer) const
597 {
598 btGeneric6DofSpring2ConstraintData2* dof = (btGeneric6DofSpring2ConstraintData2*)dataBuffer;
599 btTypedConstraint::serialize(&dof->m_typeConstraintData,serializer);
600
601 m_frameInA.serialize(dof->m_rbAFrame);
602 m_frameInB.serialize(dof->m_rbBFrame);
603
604 int i;
605 for (i=0;i<3;i++)
606 {
607 dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit;
608 dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit;
609 dof->m_angularBounce.m_floats[i] = m_angularLimits[i].m_bounce;
610 dof->m_angularStopERP.m_floats[i] = m_angularLimits[i].m_stopERP;
611 dof->m_angularStopCFM.m_floats[i] = m_angularLimits[i].m_stopCFM;
612 dof->m_angularMotorERP.m_floats[i] = m_angularLimits[i].m_motorERP;
613 dof->m_angularMotorCFM.m_floats[i] = m_angularLimits[i].m_motorCFM;
614 dof->m_angularTargetVelocity.m_floats[i] = m_angularLimits[i].m_targetVelocity;
615 dof->m_angularMaxMotorForce.m_floats[i] = m_angularLimits[i].m_maxMotorForce;
616 dof->m_angularServoTarget.m_floats[i] = m_angularLimits[i].m_servoTarget;
617 dof->m_angularSpringStiffness.m_floats[i] = m_angularLimits[i].m_springStiffness;
618 dof->m_angularSpringDamping.m_floats[i] = m_angularLimits[i].m_springDamping;
619 dof->m_angularEquilibriumPoint.m_floats[i] = m_angularLimits[i].m_equilibriumPoint;
620 }
621 dof->m_angularLowerLimit.m_floats[3] = 0;
622 dof->m_angularUpperLimit.m_floats[3] = 0;
623 dof->m_angularBounce.m_floats[3] = 0;
624 dof->m_angularStopERP.m_floats[3] = 0;
625 dof->m_angularStopCFM.m_floats[3] = 0;
626 dof->m_angularMotorERP.m_floats[3] = 0;
627 dof->m_angularMotorCFM.m_floats[3] = 0;
628 dof->m_angularTargetVelocity.m_floats[3] = 0;
629 dof->m_angularMaxMotorForce.m_floats[3] = 0;
630 dof->m_angularServoTarget.m_floats[3] = 0;
631 dof->m_angularSpringStiffness.m_floats[3] = 0;
632 dof->m_angularSpringDamping.m_floats[3] = 0;
633 dof->m_angularEquilibriumPoint.m_floats[3] = 0;
634 for (i=0;i<4;i++)
635 {
636 dof->m_angularEnableMotor[i] = i < 3 ? ( m_angularLimits[i].m_enableMotor ? 1 : 0 ) : 0;
637 dof->m_angularServoMotor[i] = i < 3 ? ( m_angularLimits[i].m_servoMotor ? 1 : 0 ) : 0;
638 dof->m_angularEnableSpring[i] = i < 3 ? ( m_angularLimits[i].m_enableSpring ? 1 : 0 ) : 0;
639 dof->m_angularSpringStiffnessLimited[i] = i < 3 ? ( m_angularLimits[i].m_springStiffnessLimited ? 1 : 0 ) : 0;
640 dof->m_angularSpringDampingLimited[i] = i < 3 ? ( m_angularLimits[i].m_springDampingLimited ? 1 : 0 ) : 0;
641 }
642
643 m_linearLimits.m_lowerLimit.serialize( dof->m_linearLowerLimit );
644 m_linearLimits.m_upperLimit.serialize( dof->m_linearUpperLimit );
645 m_linearLimits.m_bounce.serialize( dof->m_linearBounce );
646 m_linearLimits.m_stopERP.serialize( dof->m_linearStopERP );
647 m_linearLimits.m_stopCFM.serialize( dof->m_linearStopCFM );
648 m_linearLimits.m_motorERP.serialize( dof->m_linearMotorERP );
649 m_linearLimits.m_motorCFM.serialize( dof->m_linearMotorCFM );
650 m_linearLimits.m_targetVelocity.serialize( dof->m_linearTargetVelocity );
651 m_linearLimits.m_maxMotorForce.serialize( dof->m_linearMaxMotorForce );
652 m_linearLimits.m_servoTarget.serialize( dof->m_linearServoTarget );
653 m_linearLimits.m_springStiffness.serialize( dof->m_linearSpringStiffness );
654 m_linearLimits.m_springDamping.serialize( dof->m_linearSpringDamping );
655 m_linearLimits.m_equilibriumPoint.serialize( dof->m_linearEquilibriumPoint );
656 for (i=0;i<4;i++)
657 {
658 dof->m_linearEnableMotor[i] = i < 3 ? ( m_linearLimits.m_enableMotor[i] ? 1 : 0 ) : 0;
659 dof->m_linearServoMotor[i] = i < 3 ? ( m_linearLimits.m_servoMotor[i] ? 1 : 0 ) : 0;
660 dof->m_linearEnableSpring[i] = i < 3 ? ( m_linearLimits.m_enableSpring[i] ? 1 : 0 ) : 0;
661 dof->m_linearSpringStiffnessLimited[i] = i < 3 ? ( m_linearLimits.m_springStiffnessLimited[i] ? 1 : 0 ) : 0;
662 dof->m_linearSpringDampingLimited[i] = i < 3 ? ( m_linearLimits.m_springDampingLimited[i] ? 1 : 0 ) : 0;
663 }
664
665 dof->m_rotateOrder = m_rotateOrder;
666
667 return btGeneric6DofSpring2ConstraintDataName;
668 }
669
670
671
672
673
674 #endif //BT_GENERIC_6DOF_CONSTRAINT_H
RO_YXZ
Definition: btGeneric6DofSpring2Constraint.h:63
btGeneric6DofSpring2ConstraintData::m_angularUpperLimit
btVector3FloatData m_angularUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:521
btGeneric6DofSpring2Constraint::getAngularUpperLimitReversed
void getAngularUpperLimitReversed(btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:419
btGeneric6DofSpring2ConstraintDoubleData2::m_rbBFrame
btTransformDoubleData m_rbBFrame
Definition: btGeneric6DofSpring2Constraint.h:547
btGeneric6DofSpring2ConstraintData::m_rotateOrder
int m_rotateOrder
Definition: btGeneric6DofSpring2Constraint.h:540
btGeneric6DofSpring2ConstraintData::m_angularSpringDampingLimited
char m_angularSpringDampingLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:538
btGeneric6DofSpring2Constraint::getAngularLowerLimitReversed
void getAngularLowerLimitReversed(btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:395
btTranslationalLimitMotor2::m_maxMotorForce
btVector3 m_maxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:188
btGeneric6DofSpring2ConstraintData::m_linearBounce
btVector3FloatData m_linearBounce
Definition: btGeneric6DofSpring2Constraint.h:503
btGeneric6DofSpring2ConstraintDoubleData2::m_linearEquilibriumPoint
btVector3DoubleData m_linearEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:561
btRotationalLimitMotor2::m_stopERP
btScalar m_stopERP
Definition: btGeneric6DofSpring2Constraint.h:78
btTranslationalLimitMotor2::m_springStiffness
btVector3 m_springStiffness
Definition: btGeneric6DofSpring2Constraint.h:182
btRotationalLimitMotor2::m_enableMotor
bool m_enableMotor
Definition: btGeneric6DofSpring2Constraint.h:82
btRotationalLimitMotor2::m_servoMotor
bool m_servoMotor
Definition: btGeneric6DofSpring2Constraint.h:85
btTranslationalLimitMotor2::testLimitValue
void testLimitValue(int limitIndex, btScalar test_value)
Definition: btGeneric6DofSpring2Constraint.cpp:1103
btVector3::setValue
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
btGeneric6DofSpring2ConstraintDoubleData2::m_padding1
char m_padding1[4]
Definition: btGeneric6DofSpring2Constraint.h:567
btGeneric6DofSpring2ConstraintDoubleData2::m_linearServoMotor
char m_linearServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:563
btRotationalLimitMotor2::m_loLimit
btScalar m_loLimit
Definition: btGeneric6DofSpring2Constraint.h:75
btGeneric6DofSpring2ConstraintData::m_typeConstraintData
btTypedConstraintData m_typeConstraintData
Definition: btGeneric6DofSpring2Constraint.h:497
btJacobianEntry
Jacobian entry is an abstraction that allows to describe constraints it can be used in combination wi...
Definition: btJacobianEntry.h:30
btGeneric6DofSpring2Constraint::m_hasStaticBody
bool m_hasStaticBody
Definition: btGeneric6DofSpring2Constraint.h:301
btGeneric6DofSpring2ConstraintDoubleData2::m_linearMotorCFM
btVector3DoubleData m_linearMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:555
btTranslationalLimitMotor2::m_stopCFM
btVector3 m_stopCFM
Definition: btGeneric6DofSpring2Constraint.h:175
btGeneric6DofSpring2ConstraintData::m_linearSpringStiffness
btVector3FloatData m_linearSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:511
btGeneric6DofSpring2ConstraintData::m_linearEquilibriumPoint
btVector3FloatData m_linearEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:513
btVector3.h
btGeneric6DofSpring2ConstraintDoubleData2::m_linearSpringDamping
btVector3DoubleData m_linearSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:560
btGeneric6DofSpring2ConstraintData::m_linearLowerLimit
btVector3FloatData m_linearLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:502
btRotationalLimitMotor2::m_motorERP
btScalar m_motorERP
Definition: btGeneric6DofSpring2Constraint.h:80
btTranslationalLimitMotor2::m_enableMotor
bool m_enableMotor[3]
Definition: btGeneric6DofSpring2Constraint.h:178
btGeneric6DofSpring2Constraint::setLimit
void setLimit(int axis, btScalar lo, btScalar hi)
Definition: btGeneric6DofSpring2Constraint.h:427
btGeneric6DofSpring2Constraint::getFrameOffsetB
btTransform & getFrameOffsetB()
Definition: btGeneric6DofSpring2Constraint.h:359
btGeneric6DofSpring2ConstraintData::m_rbBFrame
btTransformFloatData m_rbBFrame
Definition: btGeneric6DofSpring2Constraint.h:499
btGeneric6DofSpring2Constraint::m_flags
int m_flags
Definition: btGeneric6DofSpring2Constraint.h:302
btGeneric6DofSpring2ConstraintDoubleData2::m_linearUpperLimit
btVector3DoubleData m_linearUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:549
btGeneric6DofSpring2ConstraintData::m_linearTargetVelocity
btVector3FloatData m_linearTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:508
btGeneric6DofSpring2Constraint::m_factB
btScalar m_factB
Definition: btGeneric6DofSpring2Constraint.h:300
btGeneric6DofSpring2Constraint::operator=
btGeneric6DofSpring2Constraint & operator=(btGeneric6DofSpring2Constraint &)
Definition: btGeneric6DofSpring2Constraint.h:304
btGeneric6DofSpring2ConstraintDoubleData2::m_angularSpringStiffnessLimited
char m_angularSpringStiffnessLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:585
btGeneric6DofSpring2ConstraintDoubleData2::m_rbAFrame
btTransformDoubleData m_rbAFrame
Definition: btGeneric6DofSpring2Constraint.h:546
btGeneric6DofSpring2Constraint::getFrameOffsetA
const btTransform & getFrameOffsetA() const
Definition: btGeneric6DofSpring2Constraint.h:355
btTranslationalLimitMotor2::m_springStiffnessLimited
bool m_springStiffnessLimited[3]
Definition: btGeneric6DofSpring2Constraint.h:183
btGeneric6DofSpring2ConstraintDoubleData2::m_angularMotorERP
btVector3DoubleData m_angularMotorERP
Definition: btGeneric6DofSpring2Constraint.h:574
btGetMatrixElem
btScalar btGetMatrixElem(const btMatrix3x3 &mat, int index)
Definition: btGeneric6DofConstraint.cpp:73
btGeneric6DofSpring2Constraint::m_factA
btScalar m_factA
Definition: btGeneric6DofSpring2Constraint.h:299
btGeneric6DofSpring2Constraint::setAngularLowerLimitReversed
void setAngularLowerLimitReversed(const btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:383
btAssert
#define btAssert(x)
Definition: btScalar.h:113
btRotationalLimitMotor2::m_springStiffnessLimited
bool m_springStiffnessLimited
Definition: btGeneric6DofSpring2Constraint.h:89
btRotationalLimitMotor2::m_maxMotorForce
btScalar m_maxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:84
btGeneric6DofSpring2ConstraintDoubleData2::m_linearEnableSpring
char m_linearEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:564
btGeneric6DofSpring2ConstraintData::m_angularLowerLimit
btVector3FloatData m_angularLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:522
btTranslationalLimitMotor2::m_springDamping
btVector3 m_springDamping
Definition: btGeneric6DofSpring2Constraint.h:184
btGeneric6DofSpring2ConstraintDoubleData2::m_typeConstraintData
btTypedConstraintDoubleData m_typeConstraintData
Definition: btGeneric6DofSpring2Constraint.h:545
BT_6DOF_FLAGS_CFM_MOTO2
Definition: btGeneric6DofSpring2Constraint.h:271
btGeneric6DofSpring2Constraint::getFrameOffsetB
const btTransform & getFrameOffsetB() const
Definition: btGeneric6DofSpring2Constraint.h:356
btGeneric6DofSpring2ConstraintDoubleData2::m_angularEquilibriumPoint
btVector3DoubleData m_angularEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:581
btGeneric6DofSpring2ConstraintData::m_angularServoTarget
btVector3FloatData m_angularServoTarget
Definition: btGeneric6DofSpring2Constraint.h:530
btGeneric6DofSpring2Constraint::getLinearLowerLimit
void getLinearLowerLimit(btVector3 &linearLower)
Definition: btGeneric6DofSpring2Constraint.h:373
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:63
btGeneric6DofSpring2ConstraintDoubleData2::m_angularServoTarget
btVector3DoubleData m_angularServoTarget
Definition: btGeneric6DofSpring2Constraint.h:578
btGeneric6DofSpring2Constraint::getAxis
btVector3 getAxis(int axis_index) const
Definition: btGeneric6DofSpring2Constraint.h:362
btTranslationalLimitMotor2::m_springDampingLimited
bool m_springDampingLimited[3]
Definition: btGeneric6DofSpring2Constraint.h:185
btGeneric6DofSpring2ConstraintData::m_angularMaxMotorForce
btVector3FloatData m_angularMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:529
btGeneric6DofSpring2ConstraintData::m_angularBounce
btVector3FloatData m_angularBounce
Definition: btGeneric6DofSpring2Constraint.h:523
btGeneric6DofSpring2ConstraintDoubleData2::m_linearTargetVelocity
btVector3DoubleData m_linearTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:556
btGeneric6DofSpring2ConstraintDoubleData2::m_angularStopCFM
btVector3DoubleData m_angularStopCFM
Definition: btGeneric6DofSpring2Constraint.h:573
btGeneric6DofSpring2ConstraintData::m_angularMotorCFM
btVector3FloatData m_angularMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:527
btRotationalLimitMotor2::isLimited
bool isLimited()
Definition: btGeneric6DofSpring2Constraint.h:154
btGeneric6DofSpring2Constraint::m_linearLimits
btTranslationalLimitMotor2 m_linearLimits
Definition: btGeneric6DofSpring2Constraint.h:287
btRotationalLimitMotor2
Definition: btGeneric6DofSpring2Constraint.h:69
btGeneric6DofSpring2ConstraintDoubleData2::m_linearBounce
btVector3DoubleData m_linearBounce
Definition: btGeneric6DofSpring2Constraint.h:551
btGeneric6DofSpring2Constraint
Definition: btGeneric6DofSpring2Constraint.h:277
btRotationalLimitMotor2::btRotationalLimitMotor2
btRotationalLimitMotor2(const btRotationalLimitMotor2 &limot)
Definition: btGeneric6DofSpring2Constraint.h:126
btSerializer
Definition: btSerializer.h:68
btGeneric6DofSpring2Constraint::getRotationOrder
RotateOrder getRotationOrder()
Definition: btGeneric6DofSpring2Constraint.h:469
btGeneric6DofSpring2Constraint::getFrameOffsetA
btTransform & getFrameOffsetA()
Definition: btGeneric6DofSpring2Constraint.h:358
RO_YZX
Definition: btGeneric6DofSpring2Constraint.h:64
btGeneric6DofSpring2Constraint::m_frameInA
btTransform m_frameInA
Definition: btGeneric6DofSpring2Constraint.h:281
btGeneric6DofSpring2ConstraintDoubleData2::m_linearMotorERP
btVector3DoubleData m_linearMotorERP
Definition: btGeneric6DofSpring2Constraint.h:554
btTranslationalLimitMotor2::m_currentLinearDiff
btVector3 m_currentLinearDiff
Definition: btGeneric6DofSpring2Constraint.h:192
btGeneric6DofSpring2Constraint::getAngularUpperLimit
void getAngularUpperLimit(btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:413
btTypedConstraint.h
btGeneric6DofSpring2Constraint::getLinearUpperLimit
void getLinearUpperLimit(btVector3 &linearUpper)
Definition: btGeneric6DofSpring2Constraint.h:375
btGeneric6DofSpring2Constraint::m_calculatedLinearDiff
btVector3 m_calculatedLinearDiff
Definition: btGeneric6DofSpring2Constraint.h:298
btGeneric6DofSpring2ConstraintData::m_linearMaxMotorForce
btVector3FloatData m_linearMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:509
btGeneric6DofSpring2ConstraintData::m_angularEnableMotor
char m_angularEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:534
btGeneric6DofSpring2ConstraintData::m_linearMotorCFM
btVector3FloatData m_linearMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:507
btGeneric6DofSpring2ConstraintData::m_angularEnableSpring
char m_angularEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:536
btGeneric6DofSpring2ConstraintDoubleData2::m_angularLowerLimit
btVector3DoubleData m_angularLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:570
btRotationalLimitMotor2::m_currentLimitError
btScalar m_currentLimitError
Definition: btGeneric6DofSpring2Constraint.h:94
btGeneric6DofSpring2Constraint::getTranslationalLimitMotor
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
Definition: btGeneric6DofSpring2Constraint.h:344
btRotationalLimitMotor2::m_springDampingLimited
bool m_springDampingLimited
Definition: btGeneric6DofSpring2Constraint.h:91
btGeneric6DofSpring2ConstraintData::m_linearUpperLimit
btVector3FloatData m_linearUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:501
btTranslationalLimitMotor2::m_bounce
btVector3 m_bounce
Definition: btGeneric6DofSpring2Constraint.h:173
btGeneric6DofSpring2ConstraintData::m_angularStopCFM
btVector3FloatData m_angularStopCFM
Definition: btGeneric6DofSpring2Constraint.h:525
btGeneric6DofSpring2ConstraintDoubleData2::m_linearSpringStiffnessLimited
char m_linearSpringStiffnessLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:565
btTranslationalLimitMotor2::isLimited
bool isLimited(int limitIndex)
Definition: btGeneric6DofSpring2Constraint.h:259
btGeneric6DofSpring2ConstraintDoubleData2::m_linearMaxMotorForce
btVector3DoubleData m_linearMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:557
btTranslationalLimitMotor2::m_lowerLimit
btVector3 m_lowerLimit
Definition: btGeneric6DofSpring2Constraint.h:171
btTranslationalLimitMotor2
Definition: btGeneric6DofSpring2Constraint.h:165
btVector3::serialize
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1340
btGeneric6DofSpring2ConstraintDoubleData2::m_rotateOrder
int m_rotateOrder
Definition: btGeneric6DofSpring2Constraint.h:588
btRotationalLimitMotor2::m_servoTarget
btScalar m_servoTarget
Definition: btGeneric6DofSpring2Constraint.h:86
btTypedConstraintDoubleData
Definition: btTypedConstraint.h:420
btRotationalLimitMotor2::m_hiLimit
btScalar m_hiLimit
Definition: btGeneric6DofSpring2Constraint.h:76
btTranslationalLimitMotor2::m_currentLimitErrorHi
btVector3 m_currentLimitErrorHi
Definition: btGeneric6DofSpring2Constraint.h:191
btGeneric6DofSpring2Constraint::m_calculatedTransformB
btTransform m_calculatedTransformB
Definition: btGeneric6DofSpring2Constraint.h:295
btRotationalLimitMotor2::m_currentLimitErrorHi
btScalar m_currentLimitErrorHi
Definition: btGeneric6DofSpring2Constraint.h:95
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:62
btGeneric6DofSpring2ConstraintDoubleData2::m_linearLowerLimit
btVector3DoubleData m_linearLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:550
btGeneric6DofSpring2ConstraintData::m_angularServoMotor
char m_angularServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:535
btGeneric6DofSpring2ConstraintDoubleData2::m_angularEnableMotor
char m_angularEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:582
btGeneric6DofSpring2Constraint::m_calculatedTransformA
btTransform m_calculatedTransformA
Definition: btGeneric6DofSpring2Constraint.h:294
BT_6DOF_FLAGS_ERP_MOTO2
Definition: btGeneric6DofSpring2Constraint.h:272
btGeneric6DofSpring2ConstraintData::m_linearServoMotor
char m_linearServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:515
btGeneric6DofSpring2ConstraintData::m_linearSpringStiffnessLimited
char m_linearSpringStiffnessLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:517
btTranslationalLimitMotor2::m_servoMotor
bool m_servoMotor[3]
Definition: btGeneric6DofSpring2Constraint.h:179
btGeneric6DofSpring2Constraint::setLinearUpperLimit
void setLinearUpperLimit(const btVector3 &linearUpper)
Definition: btGeneric6DofSpring2Constraint.h:374
btTranslationalLimitMotor2::m_equilibriumPoint
btVector3 m_equilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:186
btGeneric6DofSpring2Constraint::getRotationalLimitMotor
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
Definition: btGeneric6DofSpring2Constraint.h:343
btTypedConstraintData
this structure is not used, except for loading pre-2.82 .bullet files
Definition: btTypedConstraint.h:397
btRotationalLimitMotor2::m_targetVelocity
btScalar m_targetVelocity
Definition: btGeneric6DofSpring2Constraint.h:83
btGeneric6DofSpring2Constraint::setLinearLowerLimit
void setLinearLowerLimit(const btVector3 &linearLower)
Definition: btGeneric6DofSpring2Constraint.h:372
RO_XZY
Definition: btGeneric6DofSpring2Constraint.h:62
btGeneric6DofSpring2Constraint::setAngularLowerLimit
void setAngularLowerLimit(const btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:377
btGeneric6DofSpring2ConstraintDoubleData2::m_angularMaxMotorForce
btVector3DoubleData m_angularMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:577
btRotationalLimitMotor2::m_bounce
btScalar m_bounce
Definition: btGeneric6DofSpring2Constraint.h:77
btRotationalLimitMotor2::m_motorCFM
btScalar m_motorCFM
Definition: btGeneric6DofSpring2Constraint.h:81
btJacobianEntry.h
btGeneric6DofSpring2Constraint::setRotationOrder
void setRotationOrder(RotateOrder order)
Definition: btGeneric6DofSpring2Constraint.h:468
btGeneric6DofSpring2Constraint::getCalculatedTransformB
const btTransform & getCalculatedTransformB() const
Definition: btGeneric6DofSpring2Constraint.h:353
btGeneric6DofSpring2ConstraintData::m_angularTargetVelocity
btVector3FloatData m_angularTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:528
btGeneric6DofSpring2ConstraintData::m_linearMotorERP
btVector3FloatData m_linearMotorERP
Definition: btGeneric6DofSpring2Constraint.h:506
btRotationalLimitMotor2::m_currentLimit
int m_currentLimit
Definition: btGeneric6DofSpring2Constraint.h:97
btGeneric6DofSpring2Constraint::buildJacobian
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly
Definition: btGeneric6DofSpring2Constraint.h:337
btTranslationalLimitMotor2::m_currentLimitError
btVector3 m_currentLimitError
Definition: btGeneric6DofSpring2Constraint.h:190
btGeneric6DofSpring2ConstraintData
Definition: btGeneric6DofSpring2Constraint.h:495
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
ATTRIBUTE_ALIGNED16
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:64
btGeneric6DofSpring2ConstraintDoubleData2::m_linearEnableMotor
char m_linearEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:562
btGeneric6DofSpring2ConstraintData::m_linearSpringDamping
btVector3FloatData m_linearSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:512
btGeneric6DofSpring2ConstraintData::m_angularSpringStiffnessLimited
char m_angularSpringStiffnessLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:537
btGeneric6DofSpring2ConstraintData::m_linearStopCFM
btVector3FloatData m_linearStopCFM
Definition: btGeneric6DofSpring2Constraint.h:505
btNormalizeAngle
btScalar btNormalizeAngle(btScalar angleInRadians)
Definition: btScalar.h:724
btGeneric6DofSpring2ConstraintData::m_linearServoTarget
btVector3FloatData m_linearServoTarget
Definition: btGeneric6DofSpring2Constraint.h:510
btGeneric6DofSpring2ConstraintDataName
#define btGeneric6DofSpring2ConstraintDataName
Definition: btGeneric6DofSpring2Constraint.h:56
btGeneric6DofSpring2Constraint::m_rotateOrder
RotateOrder m_rotateOrder
Definition: btGeneric6DofSpring2Constraint.h:290
RO_ZYX
Definition: btGeneric6DofSpring2Constraint.h:66
matrixToEulerXYZ
bool matrixToEulerXYZ(const btMatrix3x3 &mat, btVector3 &xyz)
MatrixToEulerXYZ from http://www.geometrictools.com/LibFoundation/Mathematics/Wm4Matrix3.inl.html.
Definition: btGeneric6DofConstraint.cpp:84
btGeneric6DofSpring2ConstraintDoubleData2::m_angularServoMotor
char m_angularServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:583
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btTranslationalLimitMotor2::m_servoTarget
btVector3 m_servoTarget
Definition: btGeneric6DofSpring2Constraint.h:181
btGeneric6DofSpring2ConstraintDoubleData2::m_linearServoTarget
btVector3DoubleData m_linearServoTarget
Definition: btGeneric6DofSpring2Constraint.h:558
btTranslationalLimitMotor2::m_stopERP
btVector3 m_stopERP
Definition: btGeneric6DofSpring2Constraint.h:174
btTranslationalLimitMotor2::m_motorCFM
btVector3 m_motorCFM
Definition: btGeneric6DofSpring2Constraint.h:177
btGeneric6DofSpring2ConstraintData::m_rbAFrame
btTransformFloatData m_rbAFrame
Definition: btGeneric6DofSpring2Constraint.h:498
btGeneric6DofSpring2ConstraintData::m_angularMotorERP
btVector3FloatData m_angularMotorERP
Definition: btGeneric6DofSpring2Constraint.h:526
btGeneric6DofSpring2Constraint::getCalculatedTransformA
const btTransform & getCalculatedTransformA() const
Definition: btGeneric6DofSpring2Constraint.h:351
btGeneric6DofSpring2ConstraintData::m_angularEquilibriumPoint
btVector3FloatData m_angularEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:533
btTypedConstraint
TypedConstraint is the baseclass for Bullet constraints and vehicles.
Definition: btTypedConstraint.h:77
btGeneric6DofSpring2Constraint::serialize
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btGeneric6DofSpring2Constraint.h:596
btGeneric6DofSpring2Constraint::getAngularLowerLimit
void getAngularLowerLimit(btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:389
btTransformFloatData
for serialization
Definition: btTransform.h:253
btGeneric6DofSpring2ConstraintData::m_linearEnableMotor
char m_linearEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:514
btTranslationalLimitMotor2::m_targetVelocity
btVector3 m_targetVelocity
Definition: btGeneric6DofSpring2Constraint.h:187
btGeneric6DofSpring2ConstraintDoubleData2::m_angularUpperLimit
btVector3DoubleData m_angularUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:569
btTranslationalLimitMotor2::m_enableSpring
bool m_enableSpring[3]
Definition: btGeneric6DofSpring2Constraint.h:180
btTranslationalLimitMotor2::m_currentLimit
int m_currentLimit[3]
Definition: btGeneric6DofSpring2Constraint.h:193
BT_DECLARE_ALIGNED_ALLOCATOR
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:388
btRotationalLimitMotor2::m_equilibriumPoint
btScalar m_equilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:92
btGeneric6DofSpring2ConstraintDoubleData2::m_angularSpringStiffness
btVector3DoubleData m_angularSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:579
btTypedConstraint::serialize
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btTypedConstraint.cpp:110
btGeneric6DofSpring2ConstraintData2
#define btGeneric6DofSpring2ConstraintData2
Definition: btGeneric6DofSpring2Constraint.h:55
btGeneric6DofSpring2Constraint::isLimited
bool isLimited(int limitIndex)
Definition: btGeneric6DofSpring2Constraint.h:459
btRotationalLimitMotor2::m_stopCFM
btScalar m_stopCFM
Definition: btGeneric6DofSpring2Constraint.h:79
btGeneric6DofSpring2ConstraintDoubleData2::m_angularMotorCFM
btVector3DoubleData m_angularMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:575
btGeneric6DofSpring2Constraint::m_angularLimits
btRotationalLimitMotor2 m_angularLimits[3]
Definition: btGeneric6DofSpring2Constraint.h:288
btGeneric6DofSpring2ConstraintDoubleData2
Definition: btGeneric6DofSpring2Constraint.h:543
btGeneric6DofSpring2Constraint::setAngularUpperLimitReversed
void setAngularUpperLimitReversed(const btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:407
RotateOrder
RotateOrder
Definition: btGeneric6DofSpring2Constraint.h:59
btGeneric6DofSpring2ConstraintData::m_angularSpringStiffness
btVector3FloatData m_angularSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:531
btGeneric6DofSpring2ConstraintDoubleData2::m_linearSpringStiffness
btVector3DoubleData m_linearSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:559
btGeneric6DofSpring2ConstraintDoubleData2::m_angularStopERP
btVector3DoubleData m_angularStopERP
Definition: btGeneric6DofSpring2Constraint.h:572
btGeneric6DofSpring2ConstraintDoubleData2::m_angularSpringDamping
btVector3DoubleData m_angularSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:580
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
BT_6DOF_FLAGS_ERP_STOP2
Definition: btGeneric6DofSpring2Constraint.h:270
btGeneric6DofSpring2Constraint::getRelativePivotPosition
btScalar getRelativePivotPosition(int axis_index) const
Definition: btGeneric6DofSpring2Constraint.h:368
RO_ZXY
Definition: btGeneric6DofSpring2Constraint.h:65
btRotationalLimitMotor2::testLimitValue
void testLimitValue(btScalar test_value)
Definition: btGeneric6DofSpring2Constraint.cpp:1084
btRotationalLimitMotor2::m_currentPosition
btScalar m_currentPosition
Definition: btGeneric6DofSpring2Constraint.h:96
btGeneric6DofSpring2Constraint::setAngularUpperLimit
void setAngularUpperLimit(const btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:401
btVector3FloatData
Definition: btVector3.h:1301
btGeneric6DofSpring2ConstraintDoubleData2::m_angularBounce
btVector3DoubleData m_angularBounce
Definition: btGeneric6DofSpring2Constraint.h:571
btGeneric6DofSpring2ConstraintDoubleData2::m_angularSpringDampingLimited
char m_angularSpringDampingLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:586
btGeneric6DofSpring2ConstraintData::m_linearStopERP
btVector3FloatData m_linearStopERP
Definition: btGeneric6DofSpring2Constraint.h:504
btTranslationalLimitMotor2::m_motorERP
btVector3 m_motorERP
Definition: btGeneric6DofSpring2Constraint.h:176
btTransform::serialize
void serialize(struct btTransformData &dataOut) const
Definition: btTransform.h:267
btGeneric6DofSpring2ConstraintData::m_linearEnableSpring
char m_linearEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:516
btGeneric6DofSpring2ConstraintData::m_linearSpringDampingLimited
char m_linearSpringDampingLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:518
btRotationalLimitMotor2::m_enableSpring
bool m_enableSpring
Definition: btGeneric6DofSpring2Constraint.h:87
btGeneric6DofSpring2Constraint::m_frameInB
btTransform m_frameInB
Definition: btGeneric6DofSpring2Constraint.h:282
btRotationalLimitMotor2::m_springStiffness
btScalar m_springStiffness
Definition: btGeneric6DofSpring2Constraint.h:88
btGeneric6DofSpring2ConstraintData::m_angularStopERP
btVector3FloatData m_angularStopERP
Definition: btGeneric6DofSpring2Constraint.h:524
btGeneric6DofSpring2Constraint::setLimitReversed
void setLimitReversed(int axis, btScalar lo, btScalar hi)
Definition: btGeneric6DofSpring2Constraint.h:443
btGeneric6DofSpring2Constraint::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btGeneric6DofSpring2Constraint.h:591
btTranslationalLimitMotor2::btTranslationalLimitMotor2
btTranslationalLimitMotor2()
Definition: btGeneric6DofSpring2Constraint.h:195
btGeneric6DofSpring2Constraint::m_calculatedAxisAngleDiff
btVector3 m_calculatedAxisAngleDiff
Definition: btGeneric6DofSpring2Constraint.h:296
btGeneric6DofSpring2ConstraintDoubleData2::m_angularTargetVelocity
btVector3DoubleData m_angularTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:576
btTransformDoubleData
Definition: btTransform.h:259
RO_XYZ
Definition: btGeneric6DofSpring2Constraint.h:61
btGeneric6DofSpring2ConstraintDoubleData2::m_linearSpringDampingLimited
char m_linearSpringDampingLimited[4]
Definition: btGeneric6DofSpring2Constraint.h:566
btGeneric6DofSpring2ConstraintDoubleData2::m_angularEnableSpring
char m_angularEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:584
btRotationalLimitMotor2::m_springDamping
btScalar m_springDamping
Definition: btGeneric6DofSpring2Constraint.h:90
btGeneric6DofSpring2ConstraintDoubleData2::m_linearStopERP
btVector3DoubleData m_linearStopERP
Definition: btGeneric6DofSpring2Constraint.h:552
btRotationalLimitMotor2::btRotationalLimitMotor2
btRotationalLimitMotor2()
Definition: btGeneric6DofSpring2Constraint.h:99
btTranslationalLimitMotor2::m_upperLimit
btVector3 m_upperLimit
Definition: btGeneric6DofSpring2Constraint.h:172
btGeneric6DofSpring2ConstraintData::m_angularSpringDamping
btVector3FloatData m_angularSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:532
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btVector3DoubleData
Definition: btVector3.h:1306
btTranslationalLimitMotor2::btTranslationalLimitMotor2
btTranslationalLimitMotor2(const btTranslationalLimitMotor2 &other)
Definition: btGeneric6DofSpring2Constraint.h:227
btGeneric6DofSpring2ConstraintDoubleData2::m_linearStopCFM
btVector3DoubleData m_linearStopCFM
Definition: btGeneric6DofSpring2Constraint.h:553
BT_6DOF_FLAGS_CFM_STOP2
Definition: btGeneric6DofSpring2Constraint.h:269
bt6DofFlags2
bt6DofFlags2
Definition: btGeneric6DofSpring2Constraint.h:267
btGeneric6DofSpring2ConstraintData::m_padding1
char m_padding1[4]
Definition: btGeneric6DofSpring2Constraint.h:519
btGeneric6DofSpring2Constraint::getAngle
btScalar getAngle(int axis_index) const
Definition: btGeneric6DofSpring2Constraint.h:365