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 btScalar m_springDamping;
90 btScalar m_equilibriumPoint;
91
92 btScalar m_currentLimitError;
93 btScalar m_currentLimitErrorHi;
94 btScalar m_currentPosition;
95 int m_currentLimit;
96
97 btRotationalLimitMotor2()
98 {
99 m_loLimit = 1.0f;
100 m_hiLimit = -1.0f;
101 m_bounce = 0.0f;
102 m_stopERP = 0.2f;
103 m_stopCFM = 0.f;
104 m_motorERP = 0.9f;
105 m_motorCFM = 0.f;
106 m_enableMotor = false;
107 m_targetVelocity = 0;
108 m_maxMotorForce = 0.1f;
109 m_servoMotor = false;
110 m_servoTarget = 0;
111 m_enableSpring = false;
112 m_springStiffness = 0;
113 m_springDamping = 0;
114 m_equilibriumPoint = 0;
115
116 m_currentLimitError = 0;
117 m_currentLimitErrorHi = 0;
118 m_currentPosition = 0;
119 m_currentLimit = 0;
120 }
121
122 btRotationalLimitMotor2(const btRotationalLimitMotor2 & limot)
123 {
124 m_loLimit = limot.m_loLimit;
125 m_hiLimit = limot.m_hiLimit;
126 m_bounce = limot.m_bounce;
127 m_stopERP = limot.m_stopERP;
128 m_stopCFM = limot.m_stopCFM;
129 m_motorERP = limot.m_motorERP;
130 m_motorCFM = limot.m_motorCFM;
131 m_enableMotor = limot.m_enableMotor;
132 m_targetVelocity = limot.m_targetVelocity;
133 m_maxMotorForce = limot.m_maxMotorForce;
134 m_servoMotor = limot.m_servoMotor;
135 m_servoTarget = limot.m_servoTarget;
136 m_enableSpring = limot.m_enableSpring;
137 m_springStiffness = limot.m_springStiffness;
138 m_springDamping = limot.m_springDamping;
139 m_equilibriumPoint = limot.m_equilibriumPoint;
140
141 m_currentLimitError = limot.m_currentLimitError;
142 m_currentLimitErrorHi = limot.m_currentLimitErrorHi;
143 m_currentPosition = limot.m_currentPosition;
144 m_currentLimit = limot.m_currentLimit;
145 }
146
147
148 bool isLimited()
149 {
150 if(m_loLimit > m_hiLimit) return false;
151 return true;
152 }
153
154 void testLimitValue(btScalar test_value);
155 };
156
157
158
159 class btTranslationalLimitMotor2
160 {
161 public:
162 // upper < lower means free
163 // upper == lower means locked
164 // upper > lower means limited
165 btVector3 m_lowerLimit;
166 btVector3 m_upperLimit;
167 btVector3 m_bounce;
168 btVector3 m_stopERP;
169 btVector3 m_stopCFM;
170 btVector3 m_motorERP;
171 btVector3 m_motorCFM;
172 bool m_enableMotor[3];
173 bool m_servoMotor[3];
174 bool m_enableSpring[3];
175 btVector3 m_servoTarget;
176 btVector3 m_springStiffness;
177 btVector3 m_springDamping;
178 btVector3 m_equilibriumPoint;
179 btVector3 m_targetVelocity;
180 btVector3 m_maxMotorForce;
181
182 btVector3 m_currentLimitError;
183 btVector3 m_currentLimitErrorHi;
184 btVector3 m_currentLinearDiff;
185 int m_currentLimit[3];
186
187 btTranslationalLimitMotor2()
188 {
189 m_lowerLimit .setValue(0.f , 0.f , 0.f );
190 m_upperLimit .setValue(0.f , 0.f , 0.f );
191 m_bounce .setValue(0.f , 0.f , 0.f );
192 m_stopERP .setValue(0.2f, 0.2f, 0.2f);
193 m_stopCFM .setValue(0.f , 0.f , 0.f );
194 m_motorERP .setValue(0.9f, 0.9f, 0.9f);
195 m_motorCFM .setValue(0.f , 0.f , 0.f );
196
197 m_currentLimitError .setValue(0.f , 0.f , 0.f );
198 m_currentLimitErrorHi.setValue(0.f , 0.f , 0.f );
199 m_currentLinearDiff .setValue(0.f , 0.f , 0.f );
200
201 for(int i=0; i < 3; i++)
202 {
203 m_enableMotor[i] = false;
204 m_servoMotor[i] = false;
205 m_enableSpring[i] = false;
206 m_servoTarget[i] = btScalar(0.f);
207 m_springStiffness[i] = btScalar(0.f);
208 m_springDamping[i] = btScalar(0.f);
209 m_equilibriumPoint[i] = btScalar(0.f);
210 m_targetVelocity[i] = btScalar(0.f);
211 m_maxMotorForce[i] = btScalar(0.f);
212
213 m_currentLimit[i] = 0;
214 }
215 }
216
217 btTranslationalLimitMotor2(const btTranslationalLimitMotor2 & other )
218 {
219 m_lowerLimit = other.m_lowerLimit;
220 m_upperLimit = other.m_upperLimit;
221 m_bounce = other.m_bounce;
222 m_stopERP = other.m_stopERP;
223 m_stopCFM = other.m_stopCFM;
224 m_motorERP = other.m_motorERP;
225 m_motorCFM = other.m_motorCFM;
226
227 m_currentLimitError = other.m_currentLimitError;
228 m_currentLimitErrorHi = other.m_currentLimitErrorHi;
229 m_currentLinearDiff = other.m_currentLinearDiff;
230
231 for(int i=0; i < 3; i++)
232 {
233 m_enableMotor[i] = other.m_enableMotor[i];
234 m_servoMotor[i] = other.m_servoMotor[i];
235 m_enableSpring[i] = other.m_enableSpring[i];
236 m_servoTarget[i] = other.m_servoTarget[i];
237 m_springStiffness[i] = other.m_springStiffness[i];
238 m_springDamping[i] = other.m_springDamping[i];
239 m_equilibriumPoint[i] = other.m_equilibriumPoint[i];
240 m_targetVelocity[i] = other.m_targetVelocity[i];
241 m_maxMotorForce[i] = other.m_maxMotorForce[i];
242
243 m_currentLimit[i] = other.m_currentLimit[i];
244 }
245 }
246
247 inline bool isLimited(int limitIndex)
248 {
249 return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
250 }
251
252 void testLimitValue(int limitIndex, btScalar test_value);
253 };
254
255 enum bt6DofFlags2
256 {
257 BT_6DOF_FLAGS_CFM_STOP2 = 1,
258 BT_6DOF_FLAGS_ERP_STOP2 = 2,
259 BT_6DOF_FLAGS_CFM_MOTO2 = 4,
260 BT_6DOF_FLAGS_ERP_MOTO2 = 8
261 };
262 #define BT_6DOF_FLAGS_AXIS_SHIFT2 4 // bits per axis
263
264
265 ATTRIBUTE_ALIGNED16(class) btGeneric6DofSpring2Constraint : public btTypedConstraint
266 {
267 protected:
268
269 btTransform m_frameInA;
270 btTransform m_frameInB;
271
272 btJacobianEntry m_jacLinear[3];
273 btJacobianEntry m_jacAng[3];
274
275 btTranslationalLimitMotor2 m_linearLimits;
276 btRotationalLimitMotor2 m_angularLimits[3];
277
278 RotateOrder m_rotateOrder;
279
280 protected:
281
282 btTransform m_calculatedTransformA;
283 btTransform m_calculatedTransformB;
284 btVector3 m_calculatedAxisAngleDiff;
285 btVector3 m_calculatedAxis[3];
286 btVector3 m_calculatedLinearDiff;
287 btScalar m_factA;
288 btScalar m_factB;
289 bool m_hasStaticBody;
290 int m_flags;
291
292 btGeneric6DofSpring2Constraint& operator=(btGeneric6DofSpring2Constraint&)
293 {
294 btAssert(0);
295 return *this;
296 }
297
298 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);
299 int setLinearLimits(btConstraintInfo2 *info, int row, const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);
300
301 void calculateLinearInfo();
302 void calculateAngleInfo();
303 void testAngularLimitMotor(int axis_index);
304
305 void calculateJacobi(btRotationalLimitMotor2* limot, const btTransform& transA,const btTransform& transB, btConstraintInfo2* info, int srow, btVector3& ax1, int rotational, int rotAllowed);
306 int get_limit_motor_info2(btRotationalLimitMotor2* limot,
307 const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB,
308 btConstraintInfo2* info, int row, btVector3& ax1, int rotational, int rotAllowed = false);
309
310 static btScalar btGetMatrixElem(const btMatrix3x3& mat, int index);
311 static bool matrixToEulerXYZ(const btMatrix3x3& mat,btVector3& xyz);
312 static bool matrixToEulerXZY(const btMatrix3x3& mat,btVector3& xyz);
313 static bool matrixToEulerYXZ(const btMatrix3x3& mat,btVector3& xyz);
314 static bool matrixToEulerYZX(const btMatrix3x3& mat,btVector3& xyz);
315 static bool matrixToEulerZXY(const btMatrix3x3& mat,btVector3& xyz);
316 static bool matrixToEulerZYX(const btMatrix3x3& mat,btVector3& xyz);
317
318 public:
319
320 BT_DECLARE_ALIGNED_ALLOCATOR();
321
322 btGeneric6DofSpring2Constraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ);
323 btGeneric6DofSpring2Constraint(btRigidBody& rbB, const btTransform& frameInB, RotateOrder rotOrder = RO_XYZ);
324
325 virtual void buildJacobian() {}
326 virtual void getInfo1 (btConstraintInfo1* info);
327 virtual void getInfo2 (btConstraintInfo2* info);
328 virtual int calculateSerializeBufferSize() const;
329 virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
330
331 btRotationalLimitMotor2* getRotationalLimitMotor(int index) { return &m_angularLimits[index]; }
332 btTranslationalLimitMotor2* getTranslationalLimitMotor() { return &m_linearLimits; }
333
334 // Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies.
335 void calculateTransforms(const btTransform& transA,const btTransform& transB);
336 void calculateTransforms();
337
338 // Gets the global transform of the offset for body A
339 const btTransform & getCalculatedTransformA() const { return m_calculatedTransformA; }
340 // Gets the global transform of the offset for body B
341 const btTransform & getCalculatedTransformB() const { return m_calculatedTransformB; }
342
343 const btTransform & getFrameOffsetA() const { return m_frameInA; }
344 const btTransform & getFrameOffsetB() const { return m_frameInB; }
345
346 btTransform & getFrameOffsetA() { return m_frameInA; }
347 btTransform & getFrameOffsetB() { return m_frameInB; }
348
349 // Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
350 btVector3 getAxis(int axis_index) const { return m_calculatedAxis[axis_index]; }
351
352 // Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
353 btScalar getAngle(int axis_index) const { return m_calculatedAxisAngleDiff[axis_index]; }
354
355 // Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously )
356 btScalar getRelativePivotPosition(int axis_index) const { return m_calculatedLinearDiff[axis_index]; }
357
358 void setFrames(const btTransform & frameA, const btTransform & frameB);
359
360 void setLinearLowerLimit(const btVector3& linearLower) { m_linearLimits.m_lowerLimit = linearLower; }
361 void getLinearLowerLimit(btVector3& linearLower) { linearLower = m_linearLimits.m_lowerLimit; }
362 void setLinearUpperLimit(const btVector3& linearUpper) { m_linearLimits.m_upperLimit = linearUpper; }
363 void getLinearUpperLimit(btVector3& linearUpper) { linearUpper = m_linearLimits.m_upperLimit; }
364
365 void setAngularLowerLimit(const btVector3& angularLower)
366 {
367 for(int i = 0; i < 3; i++)
368 m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]);
369 }
370
371 void setAngularLowerLimitReversed(const btVector3& angularLower)
372 {
373 for(int i = 0; i < 3; i++)
374 m_angularLimits[i].m_hiLimit = btNormalizeAngle(-angularLower[i]);
375 }
376
377 void getAngularLowerLimit(btVector3& angularLower)
378 {
379 for(int i = 0; i < 3; i++)
380 angularLower[i] = m_angularLimits[i].m_loLimit;
381 }
382
383 void getAngularLowerLimitReversed(btVector3& angularLower)
384 {
385 for(int i = 0; i < 3; i++)
386 angularLower[i] = -m_angularLimits[i].m_hiLimit;
387 }
388
389 void setAngularUpperLimit(const btVector3& angularUpper)
390 {
391 for(int i = 0; i < 3; i++)
392 m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
393 }
394
395 void setAngularUpperLimitReversed(const btVector3& angularUpper)
396 {
397 for(int i = 0; i < 3; i++)
398 m_angularLimits[i].m_loLimit = btNormalizeAngle(-angularUpper[i]);
399 }
400
401 void getAngularUpperLimit(btVector3& angularUpper)
402 {
403 for(int i = 0; i < 3; i++)
404 angularUpper[i] = m_angularLimits[i].m_hiLimit;
405 }
406
407 void getAngularUpperLimitReversed(btVector3& angularUpper)
408 {
409 for(int i = 0; i < 3; i++)
410 angularUpper[i] = -m_angularLimits[i].m_loLimit;
411 }
412
413 //first 3 are linear, next 3 are angular
414
415 void setLimit(int axis, btScalar lo, btScalar hi)
416 {
417 if(axis<3)
418 {
419 m_linearLimits.m_lowerLimit[axis] = lo;
420 m_linearLimits.m_upperLimit[axis] = hi;
421 }
422 else
423 {
424 lo = btNormalizeAngle(lo);
425 hi = btNormalizeAngle(hi);
426 m_angularLimits[axis-3].m_loLimit = lo;
427 m_angularLimits[axis-3].m_hiLimit = hi;
428 }
429 }
430
431 void setLimitReversed(int axis, btScalar lo, btScalar hi)
432 {
433 if(axis<3)
434 {
435 m_linearLimits.m_lowerLimit[axis] = lo;
436 m_linearLimits.m_upperLimit[axis] = hi;
437 }
438 else
439 {
440 lo = btNormalizeAngle(lo);
441 hi = btNormalizeAngle(hi);
442 m_angularLimits[axis-3].m_hiLimit = -lo;
443 m_angularLimits[axis-3].m_loLimit = -hi;
444 }
445 }
446
447 bool isLimited(int limitIndex)
448 {
449 if(limitIndex<3)
450 {
451 return m_linearLimits.isLimited(limitIndex);
452 }
453 return m_angularLimits[limitIndex-3].isLimited();
454 }
455
456 void setRotationOrder(RotateOrder order) { m_rotateOrder = order; }
457 RotateOrder getRotationOrder() { return m_rotateOrder; }
458
459 void setAxis( const btVector3& axis1, const btVector3& axis2);
460
461 void setBounce(int index, btScalar bounce);
462
463 void enableMotor(int index, bool onOff);
464 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)
465 void setTargetVelocity(int index, btScalar velocity);
466 void setServoTarget(int index, btScalar target);
467 void setMaxMotorForce(int index, btScalar force);
468
469 void enableSpring(int index, bool onOff);
470 void setStiffness(int index, btScalar stiffness);
471 void setDamping(int index, btScalar damping);
472 void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF
473 void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF
474 void setEquilibriumPoint(int index, btScalar val);
475
476 //override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5).
477 //If no axis is provided, it uses the default axis for this constraint.
478 virtual void setParam(int num, btScalar value, int axis = -1);
479 virtual btScalar getParam(int num, int axis = -1) const;
480 };
481
482
483 struct btGeneric6DofSpring2ConstraintData
484 {
485 btTypedConstraintData m_typeConstraintData;
486 btTransformFloatData m_rbAFrame;
487 btTransformFloatData m_rbBFrame;
488
489 btVector3FloatData m_linearUpperLimit;
490 btVector3FloatData m_linearLowerLimit;
491 btVector3FloatData m_linearBounce;
492 btVector3FloatData m_linearStopERP;
493 btVector3FloatData m_linearStopCFM;
494 btVector3FloatData m_linearMotorERP;
495 btVector3FloatData m_linearMotorCFM;
496 btVector3FloatData m_linearTargetVelocity;
497 btVector3FloatData m_linearMaxMotorForce;
498 btVector3FloatData m_linearServoTarget;
499 btVector3FloatData m_linearSpringStiffness;
500 btVector3FloatData m_linearSpringDamping;
501 btVector3FloatData m_linearEquilibriumPoint;
502 char m_linearEnableMotor[4];
503 char m_linearServoMotor[4];
504 char m_linearEnableSpring[4];
505 char m_padding1[4];
506
507 btVector3FloatData m_angularUpperLimit;
508 btVector3FloatData m_angularLowerLimit;
509 btVector3FloatData m_angularBounce;
510 btVector3FloatData m_angularStopERP;
511 btVector3FloatData m_angularStopCFM;
512 btVector3FloatData m_angularMotorERP;
513 btVector3FloatData m_angularMotorCFM;
514 btVector3FloatData m_angularTargetVelocity;
515 btVector3FloatData m_angularMaxMotorForce;
516 btVector3FloatData m_angularServoTarget;
517 btVector3FloatData m_angularSpringStiffness;
518 btVector3FloatData m_angularSpringDamping;
519 btVector3FloatData m_angularEquilibriumPoint;
520 char m_angularEnableMotor[4];
521 char m_angularServoMotor[4];
522 char m_angularEnableSpring[4];
523 char m_padding2[4];
524
525 int m_rotateOrder;
526 char m_padding3[4];
527 };
528
529 struct btGeneric6DofSpring2ConstraintDoubleData2
530 {
531 btTypedConstraintDoubleData m_typeConstraintData;
532 btTransformDoubleData m_rbAFrame;
533 btTransformDoubleData m_rbBFrame;
534
535 btVector3DoubleData m_linearUpperLimit;
536 btVector3DoubleData m_linearLowerLimit;
537 btVector3DoubleData m_linearBounce;
538 btVector3DoubleData m_linearStopERP;
539 btVector3DoubleData m_linearStopCFM;
540 btVector3DoubleData m_linearMotorERP;
541 btVector3DoubleData m_linearMotorCFM;
542 btVector3DoubleData m_linearTargetVelocity;
543 btVector3DoubleData m_linearMaxMotorForce;
544 btVector3DoubleData m_linearServoTarget;
545 btVector3DoubleData m_linearSpringStiffness;
546 btVector3DoubleData m_linearSpringDamping;
547 btVector3DoubleData m_linearEquilibriumPoint;
548 char m_linearEnableMotor[4];
549 char m_linearServoMotor[4];
550 char m_linearEnableSpring[4];
551 char m_padding1[4];
552
553 btVector3DoubleData m_angularUpperLimit;
554 btVector3DoubleData m_angularLowerLimit;
555 btVector3DoubleData m_angularBounce;
556 btVector3DoubleData m_angularStopERP;
557 btVector3DoubleData m_angularStopCFM;
558 btVector3DoubleData m_angularMotorERP;
559 btVector3DoubleData m_angularMotorCFM;
560 btVector3DoubleData m_angularTargetVelocity;
561 btVector3DoubleData m_angularMaxMotorForce;
562 btVector3DoubleData m_angularServoTarget;
563 btVector3DoubleData m_angularSpringStiffness;
564 btVector3DoubleData m_angularSpringDamping;
565 btVector3DoubleData m_angularEquilibriumPoint;
566 char m_angularEnableMotor[4];
567 char m_angularServoMotor[4];
568 char m_angularEnableSpring[4];
569 char m_padding2[4];
570
571 int m_rotateOrder;
572 char m_padding3[4];
573 };
574
575 SIMD_FORCE_INLINE int btGeneric6DofSpring2Constraint::calculateSerializeBufferSize() const
576 {
577 return sizeof(btGeneric6DofSpring2ConstraintData2);
578 }
579
580 SIMD_FORCE_INLINE const char* btGeneric6DofSpring2Constraint::serialize(void* dataBuffer, btSerializer* serializer) const
581 {
582 btGeneric6DofSpring2ConstraintData2* dof = (btGeneric6DofSpring2ConstraintData2*)dataBuffer;
583 btTypedConstraint::serialize(&dof->m_typeConstraintData,serializer);
584
585 m_frameInA.serialize(dof->m_rbAFrame);
586 m_frameInB.serialize(dof->m_rbBFrame);
587
588 int i;
589 for (i=0;i<3;i++)
590 {
591 dof->m_angularLowerLimit.m_floats[i] = m_angularLimits[i].m_loLimit;
592 dof->m_angularUpperLimit.m_floats[i] = m_angularLimits[i].m_hiLimit;
593 dof->m_angularBounce.m_floats[i] = m_angularLimits[i].m_bounce;
594 dof->m_angularStopERP.m_floats[i] = m_angularLimits[i].m_stopERP;
595 dof->m_angularStopCFM.m_floats[i] = m_angularLimits[i].m_stopCFM;
596 dof->m_angularMotorERP.m_floats[i] = m_angularLimits[i].m_motorERP;
597 dof->m_angularMotorCFM.m_floats[i] = m_angularLimits[i].m_motorCFM;
598 dof->m_angularTargetVelocity.m_floats[i] = m_angularLimits[i].m_targetVelocity;
599 dof->m_angularMaxMotorForce.m_floats[i] = m_angularLimits[i].m_maxMotorForce;
600 dof->m_angularServoTarget.m_floats[i] = m_angularLimits[i].m_servoTarget;
601 dof->m_angularSpringStiffness.m_floats[i] = m_angularLimits[i].m_springStiffness;
602 dof->m_angularSpringDamping.m_floats[i] = m_angularLimits[i].m_springDamping;
603 dof->m_angularEquilibriumPoint.m_floats[i] = m_angularLimits[i].m_equilibriumPoint;
604 }
605 dof->m_angularLowerLimit.m_floats[3] = 0;
606 dof->m_angularUpperLimit.m_floats[3] = 0;
607 dof->m_angularBounce.m_floats[3] = 0;
608 dof->m_angularStopERP.m_floats[3] = 0;
609 dof->m_angularStopCFM.m_floats[3] = 0;
610 dof->m_angularMotorERP.m_floats[3] = 0;
611 dof->m_angularMotorCFM.m_floats[3] = 0;
612 dof->m_angularTargetVelocity.m_floats[3] = 0;
613 dof->m_angularMaxMotorForce.m_floats[3] = 0;
614 dof->m_angularServoTarget.m_floats[3] = 0;
615 dof->m_angularSpringStiffness.m_floats[3] = 0;
616 dof->m_angularSpringDamping.m_floats[3] = 0;
617 dof->m_angularEquilibriumPoint.m_floats[3] = 0;
618 for (i=0;i<4;i++)
619 {
620 dof->m_angularEnableMotor[i] = i < 3 ? ( m_angularLimits[i].m_enableMotor ? 1 : 0 ) : 0;
621 dof->m_angularServoMotor[i] = i < 3 ? ( m_angularLimits[i].m_servoMotor ? 1 : 0 ) : 0;
622 dof->m_angularEnableSpring[i] = i < 3 ? ( m_angularLimits[i].m_enableSpring ? 1 : 0 ) : 0;
623 }
624
625 m_linearLimits.m_lowerLimit.serialize( dof->m_linearLowerLimit );
626 m_linearLimits.m_upperLimit.serialize( dof->m_linearUpperLimit );
627 m_linearLimits.m_bounce.serialize( dof->m_linearBounce );
628 m_linearLimits.m_stopERP.serialize( dof->m_linearStopERP );
629 m_linearLimits.m_stopCFM.serialize( dof->m_linearStopCFM );
630 m_linearLimits.m_motorERP.serialize( dof->m_linearMotorERP );
631 m_linearLimits.m_motorCFM.serialize( dof->m_linearMotorCFM );
632 m_linearLimits.m_targetVelocity.serialize( dof->m_linearTargetVelocity );
633 m_linearLimits.m_maxMotorForce.serialize( dof->m_linearMaxMotorForce );
634 m_linearLimits.m_servoTarget.serialize( dof->m_linearServoTarget );
635 m_linearLimits.m_springStiffness.serialize( dof->m_linearSpringStiffness );
636 m_linearLimits.m_springDamping.serialize( dof->m_linearSpringDamping );
637 m_linearLimits.m_equilibriumPoint.serialize( dof->m_linearEquilibriumPoint );
638 for (i=0;i<4;i++)
639 {
640 dof->m_linearEnableMotor[i] = i < 3 ? ( m_linearLimits.m_enableMotor[i] ? 1 : 0 ) : 0;
641 dof->m_linearServoMotor[i] = i < 3 ? ( m_linearLimits.m_servoMotor[i] ? 1 : 0 ) : 0;
642 dof->m_linearEnableSpring[i] = i < 3 ? ( m_linearLimits.m_enableSpring[i] ? 1 : 0 ) : 0;
643 }
644
645 dof->m_rotateOrder = m_rotateOrder;
646
647 return btGeneric6DofSpring2ConstraintDataName;
648 }
649
650
651
652
653
654 #endif //BT_GENERIC_6DOF_CONSTRAINT_H
RO_YXZ
Definition: btGeneric6DofSpring2Constraint.h:63
btGeneric6DofSpring2ConstraintData::m_angularUpperLimit
btVector3FloatData m_angularUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:507
btGeneric6DofSpring2Constraint::getAngularUpperLimitReversed
void getAngularUpperLimitReversed(btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:407
btGeneric6DofSpring2ConstraintDoubleData2::m_rbBFrame
btTransformDoubleData m_rbBFrame
Definition: btGeneric6DofSpring2Constraint.h:533
btGeneric6DofSpring2ConstraintData::m_rotateOrder
int m_rotateOrder
Definition: btGeneric6DofSpring2Constraint.h:525
btGeneric6DofSpring2Constraint::getAngularLowerLimitReversed
void getAngularLowerLimitReversed(btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:383
btTranslationalLimitMotor2::m_maxMotorForce
btVector3 m_maxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:180
btGeneric6DofSpring2ConstraintData::m_linearBounce
btVector3FloatData m_linearBounce
Definition: btGeneric6DofSpring2Constraint.h:491
btGeneric6DofSpring2ConstraintDoubleData2::m_linearEquilibriumPoint
btVector3DoubleData m_linearEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:547
btRotationalLimitMotor2::m_stopERP
btScalar m_stopERP
Definition: btGeneric6DofSpring2Constraint.h:78
btTranslationalLimitMotor2::m_springStiffness
btVector3 m_springStiffness
Definition: btGeneric6DofSpring2Constraint.h:176
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:1095
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:551
btGeneric6DofSpring2ConstraintDoubleData2::m_linearServoMotor
char m_linearServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:549
btRotationalLimitMotor2::m_loLimit
btScalar m_loLimit
Definition: btGeneric6DofSpring2Constraint.h:75
btGeneric6DofSpring2ConstraintData::m_padding2
char m_padding2[4]
Definition: btGeneric6DofSpring2Constraint.h:523
btGeneric6DofSpring2ConstraintData::m_typeConstraintData
btTypedConstraintData m_typeConstraintData
Definition: btGeneric6DofSpring2Constraint.h:485
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:289
btGeneric6DofSpring2ConstraintDoubleData2::m_linearMotorCFM
btVector3DoubleData m_linearMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:541
btTranslationalLimitMotor2::m_stopCFM
btVector3 m_stopCFM
Definition: btGeneric6DofSpring2Constraint.h:169
btGeneric6DofSpring2ConstraintData::m_linearSpringStiffness
btVector3FloatData m_linearSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:499
btGeneric6DofSpring2ConstraintData::m_linearEquilibriumPoint
btVector3FloatData m_linearEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:501
btVector3.h
btGeneric6DofSpring2ConstraintDoubleData2::m_linearSpringDamping
btVector3DoubleData m_linearSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:546
btGeneric6DofSpring2ConstraintData::m_linearLowerLimit
btVector3FloatData m_linearLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:490
btRotationalLimitMotor2::m_motorERP
btScalar m_motorERP
Definition: btGeneric6DofSpring2Constraint.h:80
btTranslationalLimitMotor2::m_enableMotor
bool m_enableMotor[3]
Definition: btGeneric6DofSpring2Constraint.h:172
btGeneric6DofSpring2Constraint::setLimit
void setLimit(int axis, btScalar lo, btScalar hi)
Definition: btGeneric6DofSpring2Constraint.h:415
btGeneric6DofSpring2Constraint::getFrameOffsetB
btTransform & getFrameOffsetB()
Definition: btGeneric6DofSpring2Constraint.h:347
btGeneric6DofSpring2ConstraintData::m_rbBFrame
btTransformFloatData m_rbBFrame
Definition: btGeneric6DofSpring2Constraint.h:487
btGeneric6DofSpring2Constraint::m_flags
int m_flags
Definition: btGeneric6DofSpring2Constraint.h:290
btGeneric6DofSpring2ConstraintDoubleData2::m_linearUpperLimit
btVector3DoubleData m_linearUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:535
btGeneric6DofSpring2ConstraintData::m_linearTargetVelocity
btVector3FloatData m_linearTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:496
btGeneric6DofSpring2Constraint::m_factB
btScalar m_factB
Definition: btGeneric6DofSpring2Constraint.h:288
btGeneric6DofSpring2Constraint::operator=
btGeneric6DofSpring2Constraint & operator=(btGeneric6DofSpring2Constraint &)
Definition: btGeneric6DofSpring2Constraint.h:292
btGeneric6DofSpring2ConstraintDoubleData2::m_rbAFrame
btTransformDoubleData m_rbAFrame
Definition: btGeneric6DofSpring2Constraint.h:532
btGeneric6DofSpring2Constraint::getFrameOffsetA
const btTransform & getFrameOffsetA() const
Definition: btGeneric6DofSpring2Constraint.h:343
btGeneric6DofSpring2ConstraintDoubleData2::m_angularMotorERP
btVector3DoubleData m_angularMotorERP
Definition: btGeneric6DofSpring2Constraint.h:558
btGetMatrixElem
btScalar btGetMatrixElem(const btMatrix3x3 &mat, int index)
Definition: btGeneric6DofConstraint.cpp:73
btGeneric6DofSpring2Constraint::m_factA
btScalar m_factA
Definition: btGeneric6DofSpring2Constraint.h:287
btGeneric6DofSpring2Constraint::setAngularLowerLimitReversed
void setAngularLowerLimitReversed(const btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:371
btAssert
#define btAssert(x)
Definition: btScalar.h:113
btRotationalLimitMotor2::m_maxMotorForce
btScalar m_maxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:84
btGeneric6DofSpring2ConstraintDoubleData2::m_linearEnableSpring
char m_linearEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:550
btGeneric6DofSpring2ConstraintData::m_angularLowerLimit
btVector3FloatData m_angularLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:508
btTranslationalLimitMotor2::m_springDamping
btVector3 m_springDamping
Definition: btGeneric6DofSpring2Constraint.h:177
btGeneric6DofSpring2ConstraintDoubleData2::m_typeConstraintData
btTypedConstraintDoubleData m_typeConstraintData
Definition: btGeneric6DofSpring2Constraint.h:531
BT_6DOF_FLAGS_CFM_MOTO2
Definition: btGeneric6DofSpring2Constraint.h:259
btGeneric6DofSpring2Constraint::getFrameOffsetB
const btTransform & getFrameOffsetB() const
Definition: btGeneric6DofSpring2Constraint.h:344
btGeneric6DofSpring2ConstraintDoubleData2::m_angularEquilibriumPoint
btVector3DoubleData m_angularEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:565
btGeneric6DofSpring2ConstraintData::m_angularServoTarget
btVector3FloatData m_angularServoTarget
Definition: btGeneric6DofSpring2Constraint.h:516
btGeneric6DofSpring2Constraint::getLinearLowerLimit
void getLinearLowerLimit(btVector3 &linearLower)
Definition: btGeneric6DofSpring2Constraint.h:361
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:63
btGeneric6DofSpring2ConstraintDoubleData2::m_angularServoTarget
btVector3DoubleData m_angularServoTarget
Definition: btGeneric6DofSpring2Constraint.h:562
btGeneric6DofSpring2Constraint::getAxis
btVector3 getAxis(int axis_index) const
Definition: btGeneric6DofSpring2Constraint.h:350
btGeneric6DofSpring2ConstraintData::m_angularMaxMotorForce
btVector3FloatData m_angularMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:515
btGeneric6DofSpring2ConstraintData::m_angularBounce
btVector3FloatData m_angularBounce
Definition: btGeneric6DofSpring2Constraint.h:509
btGeneric6DofSpring2ConstraintDoubleData2::m_linearTargetVelocity
btVector3DoubleData m_linearTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:542
btGeneric6DofSpring2ConstraintDoubleData2::m_angularStopCFM
btVector3DoubleData m_angularStopCFM
Definition: btGeneric6DofSpring2Constraint.h:557
btGeneric6DofSpring2ConstraintData::m_angularMotorCFM
btVector3FloatData m_angularMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:513
btRotationalLimitMotor2::isLimited
bool isLimited()
Definition: btGeneric6DofSpring2Constraint.h:148
btGeneric6DofSpring2Constraint::m_linearLimits
btTranslationalLimitMotor2 m_linearLimits
Definition: btGeneric6DofSpring2Constraint.h:275
btGeneric6DofSpring2ConstraintData::m_padding3
char m_padding3[4]
Definition: btGeneric6DofSpring2Constraint.h:526
btRotationalLimitMotor2
Definition: btGeneric6DofSpring2Constraint.h:69
btGeneric6DofSpring2ConstraintDoubleData2::m_linearBounce
btVector3DoubleData m_linearBounce
Definition: btGeneric6DofSpring2Constraint.h:537
btGeneric6DofSpring2Constraint
Definition: btGeneric6DofSpring2Constraint.h:265
btRotationalLimitMotor2::btRotationalLimitMotor2
btRotationalLimitMotor2(const btRotationalLimitMotor2 &limot)
Definition: btGeneric6DofSpring2Constraint.h:122
btSerializer
Definition: btSerializer.h:68
btGeneric6DofSpring2Constraint::getRotationOrder
RotateOrder getRotationOrder()
Definition: btGeneric6DofSpring2Constraint.h:457
btGeneric6DofSpring2Constraint::getFrameOffsetA
btTransform & getFrameOffsetA()
Definition: btGeneric6DofSpring2Constraint.h:346
RO_YZX
Definition: btGeneric6DofSpring2Constraint.h:64
btGeneric6DofSpring2Constraint::m_frameInA
btTransform m_frameInA
Definition: btGeneric6DofSpring2Constraint.h:269
btGeneric6DofSpring2ConstraintDoubleData2::m_linearMotorERP
btVector3DoubleData m_linearMotorERP
Definition: btGeneric6DofSpring2Constraint.h:540
btTranslationalLimitMotor2::m_currentLinearDiff
btVector3 m_currentLinearDiff
Definition: btGeneric6DofSpring2Constraint.h:184
btGeneric6DofSpring2Constraint::getAngularUpperLimit
void getAngularUpperLimit(btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:401
btTypedConstraint.h
btGeneric6DofSpring2Constraint::getLinearUpperLimit
void getLinearUpperLimit(btVector3 &linearUpper)
Definition: btGeneric6DofSpring2Constraint.h:363
btGeneric6DofSpring2Constraint::m_calculatedLinearDiff
btVector3 m_calculatedLinearDiff
Definition: btGeneric6DofSpring2Constraint.h:286
btGeneric6DofSpring2ConstraintDoubleData2::m_padding2
char m_padding2[4]
Definition: btGeneric6DofSpring2Constraint.h:569
btGeneric6DofSpring2ConstraintData::m_linearMaxMotorForce
btVector3FloatData m_linearMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:497
btGeneric6DofSpring2ConstraintData::m_angularEnableMotor
char m_angularEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:520
btGeneric6DofSpring2ConstraintData::m_linearMotorCFM
btVector3FloatData m_linearMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:495
btGeneric6DofSpring2ConstraintData::m_angularEnableSpring
char m_angularEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:522
btGeneric6DofSpring2ConstraintDoubleData2::m_angularLowerLimit
btVector3DoubleData m_angularLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:554
btRotationalLimitMotor2::m_currentLimitError
btScalar m_currentLimitError
Definition: btGeneric6DofSpring2Constraint.h:92
btGeneric6DofSpring2Constraint::getTranslationalLimitMotor
btTranslationalLimitMotor2 * getTranslationalLimitMotor()
Definition: btGeneric6DofSpring2Constraint.h:332
btGeneric6DofSpring2ConstraintData::m_linearUpperLimit
btVector3FloatData m_linearUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:489
btTranslationalLimitMotor2::m_bounce
btVector3 m_bounce
Definition: btGeneric6DofSpring2Constraint.h:167
btGeneric6DofSpring2ConstraintData::m_angularStopCFM
btVector3FloatData m_angularStopCFM
Definition: btGeneric6DofSpring2Constraint.h:511
btTranslationalLimitMotor2::isLimited
bool isLimited(int limitIndex)
Definition: btGeneric6DofSpring2Constraint.h:247
btGeneric6DofSpring2ConstraintDoubleData2::m_linearMaxMotorForce
btVector3DoubleData m_linearMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:543
btTranslationalLimitMotor2::m_lowerLimit
btVector3 m_lowerLimit
Definition: btGeneric6DofSpring2Constraint.h:165
btTranslationalLimitMotor2
Definition: btGeneric6DofSpring2Constraint.h:159
btVector3::serialize
void serialize(struct btVector3Data &dataOut) const
Definition: btVector3.h:1340
btGeneric6DofSpring2ConstraintDoubleData2::m_rotateOrder
int m_rotateOrder
Definition: btGeneric6DofSpring2Constraint.h:571
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:183
btGeneric6DofSpring2Constraint::m_calculatedTransformB
btTransform m_calculatedTransformB
Definition: btGeneric6DofSpring2Constraint.h:283
btRotationalLimitMotor2::m_currentLimitErrorHi
btScalar m_currentLimitErrorHi
Definition: btGeneric6DofSpring2Constraint.h:93
btRigidBody
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:62
btGeneric6DofSpring2ConstraintDoubleData2::m_linearLowerLimit
btVector3DoubleData m_linearLowerLimit
Definition: btGeneric6DofSpring2Constraint.h:536
btGeneric6DofSpring2ConstraintData::m_angularServoMotor
char m_angularServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:521
btGeneric6DofSpring2ConstraintDoubleData2::m_angularEnableMotor
char m_angularEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:566
btGeneric6DofSpring2Constraint::m_calculatedTransformA
btTransform m_calculatedTransformA
Definition: btGeneric6DofSpring2Constraint.h:282
BT_6DOF_FLAGS_ERP_MOTO2
Definition: btGeneric6DofSpring2Constraint.h:260
btGeneric6DofSpring2ConstraintData::m_linearServoMotor
char m_linearServoMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:503
btTranslationalLimitMotor2::m_servoMotor
bool m_servoMotor[3]
Definition: btGeneric6DofSpring2Constraint.h:173
btGeneric6DofSpring2Constraint::setLinearUpperLimit
void setLinearUpperLimit(const btVector3 &linearUpper)
Definition: btGeneric6DofSpring2Constraint.h:362
btTranslationalLimitMotor2::m_equilibriumPoint
btVector3 m_equilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:178
btGeneric6DofSpring2Constraint::getRotationalLimitMotor
btRotationalLimitMotor2 * getRotationalLimitMotor(int index)
Definition: btGeneric6DofSpring2Constraint.h:331
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:360
RO_XZY
Definition: btGeneric6DofSpring2Constraint.h:62
btGeneric6DofSpring2Constraint::setAngularLowerLimit
void setAngularLowerLimit(const btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:365
btGeneric6DofSpring2ConstraintDoubleData2::m_angularMaxMotorForce
btVector3DoubleData m_angularMaxMotorForce
Definition: btGeneric6DofSpring2Constraint.h:561
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:456
btGeneric6DofSpring2Constraint::getCalculatedTransformB
const btTransform & getCalculatedTransformB() const
Definition: btGeneric6DofSpring2Constraint.h:341
btGeneric6DofSpring2ConstraintData::m_angularTargetVelocity
btVector3FloatData m_angularTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:514
btGeneric6DofSpring2ConstraintData::m_linearMotorERP
btVector3FloatData m_linearMotorERP
Definition: btGeneric6DofSpring2Constraint.h:494
btRotationalLimitMotor2::m_currentLimit
int m_currentLimit
Definition: btGeneric6DofSpring2Constraint.h:95
btGeneric6DofSpring2Constraint::buildJacobian
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly
Definition: btGeneric6DofSpring2Constraint.h:325
btTranslationalLimitMotor2::m_currentLimitError
btVector3 m_currentLimitError
Definition: btGeneric6DofSpring2Constraint.h:182
btGeneric6DofSpring2ConstraintData
Definition: btGeneric6DofSpring2Constraint.h:483
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:548
btGeneric6DofSpring2ConstraintData::m_linearSpringDamping
btVector3FloatData m_linearSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:500
btGeneric6DofSpring2ConstraintData::m_linearStopCFM
btVector3FloatData m_linearStopCFM
Definition: btGeneric6DofSpring2Constraint.h:493
btNormalizeAngle
btScalar btNormalizeAngle(btScalar angleInRadians)
Definition: btScalar.h:724
btGeneric6DofSpring2ConstraintData::m_linearServoTarget
btVector3FloatData m_linearServoTarget
Definition: btGeneric6DofSpring2Constraint.h:498
btGeneric6DofSpring2ConstraintDataName
#define btGeneric6DofSpring2ConstraintDataName
Definition: btGeneric6DofSpring2Constraint.h:56
btGeneric6DofSpring2Constraint::m_rotateOrder
RotateOrder m_rotateOrder
Definition: btGeneric6DofSpring2Constraint.h:278
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:567
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:175
btGeneric6DofSpring2ConstraintDoubleData2::m_linearServoTarget
btVector3DoubleData m_linearServoTarget
Definition: btGeneric6DofSpring2Constraint.h:544
btTranslationalLimitMotor2::m_stopERP
btVector3 m_stopERP
Definition: btGeneric6DofSpring2Constraint.h:168
btTranslationalLimitMotor2::m_motorCFM
btVector3 m_motorCFM
Definition: btGeneric6DofSpring2Constraint.h:171
btGeneric6DofSpring2ConstraintData::m_rbAFrame
btTransformFloatData m_rbAFrame
Definition: btGeneric6DofSpring2Constraint.h:486
btGeneric6DofSpring2ConstraintData::m_angularMotorERP
btVector3FloatData m_angularMotorERP
Definition: btGeneric6DofSpring2Constraint.h:512
btGeneric6DofSpring2Constraint::getCalculatedTransformA
const btTransform & getCalculatedTransformA() const
Definition: btGeneric6DofSpring2Constraint.h:339
btGeneric6DofSpring2ConstraintData::m_angularEquilibriumPoint
btVector3FloatData m_angularEquilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:519
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:580
btGeneric6DofSpring2Constraint::getAngularLowerLimit
void getAngularLowerLimit(btVector3 &angularLower)
Definition: btGeneric6DofSpring2Constraint.h:377
btTransformFloatData
for serialization
Definition: btTransform.h:253
btGeneric6DofSpring2ConstraintData::m_linearEnableMotor
char m_linearEnableMotor[4]
Definition: btGeneric6DofSpring2Constraint.h:502
btTranslationalLimitMotor2::m_targetVelocity
btVector3 m_targetVelocity
Definition: btGeneric6DofSpring2Constraint.h:179
btGeneric6DofSpring2ConstraintDoubleData2::m_angularUpperLimit
btVector3DoubleData m_angularUpperLimit
Definition: btGeneric6DofSpring2Constraint.h:553
btTranslationalLimitMotor2::m_enableSpring
bool m_enableSpring[3]
Definition: btGeneric6DofSpring2Constraint.h:174
btTranslationalLimitMotor2::m_currentLimit
int m_currentLimit[3]
Definition: btGeneric6DofSpring2Constraint.h:185
BT_DECLARE_ALIGNED_ALLOCATOR
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:388
btRotationalLimitMotor2::m_equilibriumPoint
btScalar m_equilibriumPoint
Definition: btGeneric6DofSpring2Constraint.h:90
btGeneric6DofSpring2ConstraintDoubleData2::m_angularSpringStiffness
btVector3DoubleData m_angularSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:563
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:447
btRotationalLimitMotor2::m_stopCFM
btScalar m_stopCFM
Definition: btGeneric6DofSpring2Constraint.h:79
btGeneric6DofSpring2ConstraintDoubleData2::m_angularMotorCFM
btVector3DoubleData m_angularMotorCFM
Definition: btGeneric6DofSpring2Constraint.h:559
btGeneric6DofSpring2Constraint::m_angularLimits
btRotationalLimitMotor2 m_angularLimits[3]
Definition: btGeneric6DofSpring2Constraint.h:276
btGeneric6DofSpring2ConstraintDoubleData2
Definition: btGeneric6DofSpring2Constraint.h:529
btGeneric6DofSpring2Constraint::setAngularUpperLimitReversed
void setAngularUpperLimitReversed(const btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:395
RotateOrder
RotateOrder
Definition: btGeneric6DofSpring2Constraint.h:59
btGeneric6DofSpring2ConstraintData::m_angularSpringStiffness
btVector3FloatData m_angularSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:517
btGeneric6DofSpring2ConstraintDoubleData2::m_linearSpringStiffness
btVector3DoubleData m_linearSpringStiffness
Definition: btGeneric6DofSpring2Constraint.h:545
btGeneric6DofSpring2ConstraintDoubleData2::m_angularStopERP
btVector3DoubleData m_angularStopERP
Definition: btGeneric6DofSpring2Constraint.h:556
btGeneric6DofSpring2ConstraintDoubleData2::m_angularSpringDamping
btVector3DoubleData m_angularSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:564
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:258
btGeneric6DofSpring2Constraint::getRelativePivotPosition
btScalar getRelativePivotPosition(int axis_index) const
Definition: btGeneric6DofSpring2Constraint.h:356
RO_ZXY
Definition: btGeneric6DofSpring2Constraint.h:65
btRotationalLimitMotor2::testLimitValue
void testLimitValue(btScalar test_value)
Definition: btGeneric6DofSpring2Constraint.cpp:1076
btRotationalLimitMotor2::m_currentPosition
btScalar m_currentPosition
Definition: btGeneric6DofSpring2Constraint.h:94
btGeneric6DofSpring2Constraint::setAngularUpperLimit
void setAngularUpperLimit(const btVector3 &angularUpper)
Definition: btGeneric6DofSpring2Constraint.h:389
btVector3FloatData
Definition: btVector3.h:1301
btGeneric6DofSpring2ConstraintDoubleData2::m_angularBounce
btVector3DoubleData m_angularBounce
Definition: btGeneric6DofSpring2Constraint.h:555
btGeneric6DofSpring2ConstraintData::m_linearStopERP
btVector3FloatData m_linearStopERP
Definition: btGeneric6DofSpring2Constraint.h:492
btTranslationalLimitMotor2::m_motorERP
btVector3 m_motorERP
Definition: btGeneric6DofSpring2Constraint.h:170
btTransform::serialize
void serialize(struct btTransformData &dataOut) const
Definition: btTransform.h:267
btGeneric6DofSpring2ConstraintData::m_linearEnableSpring
char m_linearEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:504
btRotationalLimitMotor2::m_enableSpring
bool m_enableSpring
Definition: btGeneric6DofSpring2Constraint.h:87
btGeneric6DofSpring2Constraint::m_frameInB
btTransform m_frameInB
Definition: btGeneric6DofSpring2Constraint.h:270
btGeneric6DofSpring2ConstraintDoubleData2::m_padding3
char m_padding3[4]
Definition: btGeneric6DofSpring2Constraint.h:572
btRotationalLimitMotor2::m_springStiffness
btScalar m_springStiffness
Definition: btGeneric6DofSpring2Constraint.h:88
btGeneric6DofSpring2ConstraintData::m_angularStopERP
btVector3FloatData m_angularStopERP
Definition: btGeneric6DofSpring2Constraint.h:510
btGeneric6DofSpring2Constraint::setLimitReversed
void setLimitReversed(int axis, btScalar lo, btScalar hi)
Definition: btGeneric6DofSpring2Constraint.h:431
btGeneric6DofSpring2Constraint::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btGeneric6DofSpring2Constraint.h:575
btTranslationalLimitMotor2::btTranslationalLimitMotor2
btTranslationalLimitMotor2()
Definition: btGeneric6DofSpring2Constraint.h:187
btGeneric6DofSpring2Constraint::m_calculatedAxisAngleDiff
btVector3 m_calculatedAxisAngleDiff
Definition: btGeneric6DofSpring2Constraint.h:284
btGeneric6DofSpring2ConstraintDoubleData2::m_angularTargetVelocity
btVector3DoubleData m_angularTargetVelocity
Definition: btGeneric6DofSpring2Constraint.h:560
btTransformDoubleData
Definition: btTransform.h:259
RO_XYZ
Definition: btGeneric6DofSpring2Constraint.h:61
btGeneric6DofSpring2ConstraintDoubleData2::m_angularEnableSpring
char m_angularEnableSpring[4]
Definition: btGeneric6DofSpring2Constraint.h:568
btRotationalLimitMotor2::m_springDamping
btScalar m_springDamping
Definition: btGeneric6DofSpring2Constraint.h:89
btGeneric6DofSpring2ConstraintDoubleData2::m_linearStopERP
btVector3DoubleData m_linearStopERP
Definition: btGeneric6DofSpring2Constraint.h:538
btRotationalLimitMotor2::btRotationalLimitMotor2
btRotationalLimitMotor2()
Definition: btGeneric6DofSpring2Constraint.h:97
btTranslationalLimitMotor2::m_upperLimit
btVector3 m_upperLimit
Definition: btGeneric6DofSpring2Constraint.h:166
btGeneric6DofSpring2ConstraintData::m_angularSpringDamping
btVector3FloatData m_angularSpringDamping
Definition: btGeneric6DofSpring2Constraint.h:518
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:217
btGeneric6DofSpring2ConstraintDoubleData2::m_linearStopCFM
btVector3DoubleData m_linearStopCFM
Definition: btGeneric6DofSpring2Constraint.h:539
BT_6DOF_FLAGS_CFM_STOP2
Definition: btGeneric6DofSpring2Constraint.h:257
bt6DofFlags2
bt6DofFlags2
Definition: btGeneric6DofSpring2Constraint.h:255
btGeneric6DofSpring2ConstraintData::m_padding1
char m_padding1[4]
Definition: btGeneric6DofSpring2Constraint.h:505
btGeneric6DofSpring2Constraint::getAngle
btScalar getAngle(int axis_index) const
Definition: btGeneric6DofSpring2Constraint.h:353