Bullet Collision Detection & Physics Library
btTypedConstraint.h
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2010 Erwin Coumans http://continuousphysics.com/Bullet/
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#ifndef BT_TYPED_CONSTRAINT_H
17#define BT_TYPED_CONSTRAINT_H
18
19
20#include "LinearMath/btScalar.h"
21#include "btSolverConstraint.h"
23
24#ifdef BT_USE_DOUBLE_PRECISION
25#define btTypedConstraintData2 btTypedConstraintDoubleData
26#define btTypedConstraintDataName "btTypedConstraintDoubleData"
27#else
28#define btTypedConstraintData2 btTypedConstraintFloatData
29#define btTypedConstraintDataName "btTypedConstraintFloatData"
30#endif //BT_USE_DOUBLE_PRECISION
31
32
33class btSerializer;
34
35//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility
37{
49};
50
51
53{
58};
59
60#if 1
61 #define btAssertConstrParams(_par) btAssert(_par)
62#else
63 #define btAssertConstrParams(_par)
64#endif
65
66
68{
74};
75
76
79{
81
82 union
83 {
86 };
87
92
93
95 {
96 btAssert(0);
97 (void) other;
98 return *this;
99 }
100
101protected:
107
109 btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact);
110
111
112public:
113
115
116 virtual ~btTypedConstraint() {};
119
122 };
123
124 static btRigidBody& getFixedBody();
125
127 // integrator parameters: frames per second (1/stepsize), default error
128 // reduction parameter (0..1).
130
131 // for the first and second body, pointers to two (linear and angular)
132 // n*3 jacobian sub matrices, stored by rows. these matrices will have
133 // been initialized to 0 on entry. if the second body is zero then the
134 // J2xx pointers may be 0.
135 btScalar *m_J1linearAxis,*m_J1angularAxis,*m_J2linearAxis,*m_J2angularAxis;
136
137 // elements to jump from one row to the next in J's
139
140 // right hand sides of the equation J*v = c + cfm * lambda. cfm is the
141 // "constraint force mixing" vector. c is set to zero on entry, cfm is
142 // set to a constant value (typically very small or zero) value on entry.
143 btScalar *m_constraintError,*cfm;
144
145 // lo and hi limits for variables (set to -/+ infinity on entry).
146 btScalar *m_lowerLimit,*m_upperLimit;
147
148 // number of solver iterations
150
151 //damping of the velocity
153 };
154
156 {
157 return m_overrideNumSolverIterations;
158 }
159
162 void setOverrideNumSolverIterations(int overideNumIterations)
163 {
164 m_overrideNumSolverIterations = overideNumIterations;
165 }
166
168 virtual void buildJacobian() {};
169
171 virtual void setupSolverConstraint(btConstraintArray& ca, int solverBodyA,int solverBodyB, btScalar timeStep)
172 {
173 (void)ca;
174 (void)solverBodyA;
175 (void)solverBodyB;
176 (void)timeStep;
177 }
178
180 virtual void getInfo1 (btConstraintInfo1* info)=0;
181
183 virtual void getInfo2 (btConstraintInfo2* info)=0;
184
187 {
188 m_appliedImpulse = appliedImpulse;
189 }
192 {
193 return m_appliedImpulse;
194 }
195
196
198 {
199 return m_breakingImpulseThreshold;
200 }
201
203 {
204 m_breakingImpulseThreshold = threshold;
205 }
206
207 bool isEnabled() const
208 {
209 return m_isEnabled;
210 }
211
212 void setEnabled(bool enabled)
213 {
214 m_isEnabled=enabled;
215 }
216
217
219 virtual void solveConstraintObsolete(btSolverBody& /*bodyA*/,btSolverBody& /*bodyB*/,btScalar /*timeStep*/) {};
220
221
223 {
224 return m_rbA;
225 }
227 {
228 return m_rbB;
229 }
230
232 {
233 return m_rbA;
234 }
236 {
237 return m_rbB;
238 }
239
241 {
242 return m_userConstraintType ;
243 }
244
245 void setUserConstraintType(int userConstraintType)
246 {
247 m_userConstraintType = userConstraintType;
248 };
249
251 {
252 m_userConstraintId = uid;
253 }
254
256 {
257 return m_userConstraintId;
258 }
259
260 void setUserConstraintPtr(void* ptr)
261 {
262 m_userConstraintPtr = ptr;
263 }
264
266 {
267 return m_userConstraintPtr;
268 }
269
271 {
272 m_jointFeedback = jointFeedback;
273 }
274
276 {
277 return m_jointFeedback;
278 }
279
281 {
282 return m_jointFeedback;
283 }
284
285
286 int getUid() const
287 {
288 return m_userConstraintId;
289 }
290
291 bool needsFeedback() const
292 {
293 return m_needsFeedback;
294 }
295
298 void enableFeedback(bool needsFeedback)
299 {
300 m_needsFeedback = needsFeedback;
301 }
302
306 {
307 btAssert(m_needsFeedback);
308 return m_appliedImpulse;
309 }
310
312 {
313 return btTypedConstraintType(m_objectType);
314 }
315
316 void setDbgDrawSize(btScalar dbgDrawSize)
317 {
318 m_dbgDrawSize = dbgDrawSize;
319 }
321 {
322 return m_dbgDrawSize;
323 }
324
327 virtual void setParam(int num, btScalar value, int axis = -1) = 0;
328
330 virtual btScalar getParam(int num, int axis = -1) const = 0;
331
332 virtual int calculateSerializeBufferSize() const;
333
335 virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
336
337};
338
339// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits
340// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI])
341SIMD_FORCE_INLINE btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
342{
343 if(angleLowerLimitInRadians >= angleUpperLimitInRadians)
344 {
345 return angleInRadians;
346 }
347 else if(angleInRadians < angleLowerLimitInRadians)
348 {
349 btScalar diffLo = btFabs(btNormalizeAngle(angleLowerLimitInRadians - angleInRadians));
350 btScalar diffHi = btFabs(btNormalizeAngle(angleUpperLimitInRadians - angleInRadians));
351 return (diffLo < diffHi) ? angleInRadians : (angleInRadians + SIMD_2_PI);
352 }
353 else if(angleInRadians > angleUpperLimitInRadians)
354 {
355 btScalar diffHi = btFabs(btNormalizeAngle(angleInRadians - angleUpperLimitInRadians));
356 btScalar diffLo = btFabs(btNormalizeAngle(angleInRadians - angleLowerLimitInRadians));
357 return (diffLo < diffHi) ? (angleInRadians - SIMD_2_PI) : angleInRadians;
358 }
359 else
360 {
361 return angleInRadians;
362 }
363}
364
367{
370 char *m_name;
371
376
379
382
385
386};
387
389
390#define BT_BACKWARDS_COMPATIBLE_SERIALIZATION
391#ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION
394{
397 char *m_name;
398
403
406
409
412
413};
414#endif //BACKWARDS_COMPATIBLE
415
417{
420 char *m_name;
421
426
429
432
435 char padding[4];
436
437};
438
439
441{
442 return sizeof(btTypedConstraintData2);
443}
444
445
446
448{
449private:
450 btScalar
458
459 bool
461
462public:
465 :m_center(0.0f),
466 m_halfRange(-1.0f),
467 m_softness(0.9f),
468 m_biasFactor(0.3f),
469 m_relaxationFactor(1.0f),
470 m_correction(0.0f),
471 m_sign(0.0f),
472 m_solveLimit(false)
473 {}
474
478 void set(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f);
479
482 void test(const btScalar angle);
483
485 inline btScalar getSoftness() const
486 {
487 return m_softness;
488 }
489
491 inline btScalar getBiasFactor() const
492 {
493 return m_biasFactor;
494 }
495
498 {
499 return m_relaxationFactor;
500 }
501
503 inline btScalar getCorrection() const
504 {
505 return m_correction;
506 }
507
509 inline btScalar getSign() const
510 {
511 return m_sign;
512 }
513
515 inline btScalar getHalfRange() const
516 {
517 return m_halfRange;
518 }
519
521 inline bool isLimit() const
522 {
523 return m_solveLimit;
524 }
525
528 void fit(btScalar& angle) const;
529
531 btScalar getError() const;
532
533 btScalar getLow() const;
534
535 btScalar getHigh() const;
536
537};
538
539
540
541#endif //BT_TYPED_CONSTRAINT_H
btScalar btNormalizeAngle(btScalar angleInRadians)
Definition: btScalar.h:759
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:82
btScalar btFabs(btScalar x)
Definition: btScalar.h:475
#define SIMD_FORCE_INLINE
Definition: btScalar.h:81
#define SIMD_2_PI
Definition: btScalar.h:505
#define btAssert(x)
Definition: btScalar.h:131
#define btTypedConstraintData2
btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
btConstraintParams
@ BT_CONSTRAINT_CFM
@ BT_CONSTRAINT_ERP
@ BT_CONSTRAINT_STOP_CFM
@ BT_CONSTRAINT_STOP_ERP
btTypedConstraintType
@ MAX_CONSTRAINT_TYPE
@ SLIDER_CONSTRAINT_TYPE
@ GEAR_CONSTRAINT_TYPE
@ CONETWIST_CONSTRAINT_TYPE
@ FIXED_CONSTRAINT_TYPE
@ POINT2POINT_CONSTRAINT_TYPE
@ D6_SPRING_2_CONSTRAINT_TYPE
@ HINGE_CONSTRAINT_TYPE
@ CONTACT_CONSTRAINT_TYPE
@ D6_SPRING_CONSTRAINT_TYPE
@ D6_CONSTRAINT_TYPE
#define btRigidBodyData
bool isLimit() const
Returns true when the last test() invocation recognized limit violation.
btScalar m_relaxationFactor
btScalar getBiasFactor() const
Returns limit's bias factor.
btScalar getLow() const
btScalar getHigh() const
btScalar getSoftness() const
Returns limit's softness.
btScalar getCorrection() const
Returns correction value evaluated when test() was invoked.
btScalar getError() const
Returns correction value multiplied by sign value.
btScalar getSign() const
Returns sign value evaluated when test() was invoked.
void test(const btScalar angle)
Checks conastaint angle against limit.
void set(btScalar low, btScalar high, btScalar _softness=0.9f, btScalar _biasFactor=0.3f, btScalar _relaxationFactor=1.0f)
Sets all limit's parameters.
void fit(btScalar &angle) const
Checks given angle against limit.
btAngularLimit()
Default constructor initializes limit as inactive, allowing free constraint movement.
btScalar getHalfRange() const
Gives half of the distance between min and max limit angle.
btScalar getRelaxationFactor() const
Returns limit's relaxation factor.
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:63
TypedConstraint is the baseclass for Bullet constraints and vehicles.
virtual void solveConstraintObsolete(btSolverBody &, btSolverBody &, btScalar)
internal method used by the constraint solver, don't use them directly
void setDbgDrawSize(btScalar dbgDrawSize)
void setEnabled(bool enabled)
virtual btScalar getParam(int num, int axis=-1) const =0
return the local value of parameter
int getOverrideNumSolverIterations() const
btJointFeedback * m_jointFeedback
btScalar internalGetAppliedImpulse()
internal method used by the constraint solver, don't use them directly
void setUserConstraintPtr(void *ptr)
void enableFeedback(bool needsFeedback)
enableFeedback will allow to read the applied linear and angular impulse use getAppliedImpulse,...
btTypedConstraint & operator=(btTypedConstraint &other)
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly
btTypedConstraintType getConstraintType() const
void setOverrideNumSolverIterations(int overideNumIterations)
override the number of constraint solver iterations used to solve this constraint -1 will use the def...
btJointFeedback * getJointFeedback()
void setUserConstraintId(int uid)
void setUserConstraintType(int userConstraintType)
void setJointFeedback(btJointFeedback *jointFeedback)
int getUserConstraintType() const
void setBreakingImpulseThreshold(btScalar threshold)
int getUserConstraintId() const
btRigidBody & getRigidBodyA()
virtual void getInfo2(btConstraintInfo2 *info)=0
internal method used by the constraint solver, don't use them directly
void internalSetAppliedImpulse(btScalar appliedImpulse)
internal method used by the constraint solver, don't use them directly
bool isEnabled() const
btScalar m_breakingImpulseThreshold
btRigidBody & getRigidBodyB()
bool needsFeedback() const
const btRigidBody & getRigidBodyA() const
virtual void setParam(int num, btScalar value, int axis=-1)=0
override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0...
btScalar getBreakingImpulseThreshold() const
virtual void setupSolverConstraint(btConstraintArray &ca, int solverBodyA, int solverBodyB, btScalar timeStep)
internal method used by the constraint solver, don't use them directly
const btRigidBody & getRigidBodyB() const
virtual void getInfo1(btConstraintInfo1 *info)=0
internal method used by the constraint solver, don't use them directly
btScalar getAppliedImpulse() const
getAppliedImpulse is an estimated total applied impulse.
virtual ~btTypedConstraint()
virtual int calculateSerializeBufferSize() const
const btJointFeedback * getJointFeedback() const
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:84
btVector3 m_appliedForceBodyA
btVector3 m_appliedTorqueBodyA
BT_DECLARE_ALIGNED_ALLOCATOR()
btVector3 m_appliedForceBodyB
btVector3 m_appliedTorqueBodyB
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btRigidBody.h:591
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btRigidBody.h:565
The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packe...
Definition: btSolverBody.h:109
this structure is not used, except for loading pre-2.82 .bullet files
btRigidBodyData * m_rbA
btRigidBodyData * m_rbB
btRigidBodyDoubleData * m_rbB
btRigidBodyDoubleData * m_rbA
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btRigidBodyFloatData * m_rbB
btRigidBodyFloatData * m_rbA
rudimentary class to provide type info
Definition: btScalar.h:778