Bullet Collision Detection & Physics Library
btTypedConstraint.h
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2010 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 #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 
33 class 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 {
73 };
74 
75 
78 {
80 
81  union
82  {
85  };
86 
91 
92 
94  {
95  btAssert(0);
96  (void) other;
97  return *this;
98  }
99 
100 protected:
106 
108  btScalar getMotorFactor(btScalar pos, btScalar lowLim, btScalar uppLim, btScalar vel, btScalar timeFact);
109 
110 
111 public:
112 
114 
115  virtual ~btTypedConstraint() {};
118 
120  int m_numConstraintRows,nub;
121  };
122 
123  static btRigidBody& getFixedBody();
124 
126  // integrator parameters: frames per second (1/stepsize), default error
127  // reduction parameter (0..1).
129 
130  // for the first and second body, pointers to two (linear and angular)
131  // n*3 jacobian sub matrices, stored by rows. these matrices will have
132  // been initialized to 0 on entry. if the second body is zero then the
133  // J2xx pointers may be 0.
134  btScalar *m_J1linearAxis,*m_J1angularAxis,*m_J2linearAxis,*m_J2angularAxis;
135 
136  // elements to jump from one row to the next in J's
137  int rowskip;
138 
139  // right hand sides of the equation J*v = c + cfm * lambda. cfm is the
140  // "constraint force mixing" vector. c is set to zero on entry, cfm is
141  // set to a constant value (typically very small or zero) value on entry.
143 
144  // lo and hi limits for variables (set to -/+ infinity on entry).
145  btScalar *m_lowerLimit,*m_upperLimit;
146 
147  // findex vector for variables. see the LCP solver interface for a
148  // description of what this does. this is set to -1 on entry.
149  // note that the returned indexes are relative to the first index of
150  // the constraint.
151  int *findex;
152  // number of solver iterations
154 
155  //damping of the velocity
157  };
158 
160  {
161  return m_overrideNumSolverIterations;
162  }
163 
166  void setOverrideNumSolverIterations(int overideNumIterations)
167  {
168  m_overrideNumSolverIterations = overideNumIterations;
169  }
170 
172  virtual void buildJacobian() {};
173 
175  virtual void setupSolverConstraint(btConstraintArray& ca, int solverBodyA,int solverBodyB, btScalar timeStep)
176  {
177  (void)ca;
178  (void)solverBodyA;
179  (void)solverBodyB;
180  (void)timeStep;
181  }
182 
184  virtual void getInfo1 (btConstraintInfo1* info)=0;
185 
187  virtual void getInfo2 (btConstraintInfo2* info)=0;
188 
190  void internalSetAppliedImpulse(btScalar appliedImpulse)
191  {
192  m_appliedImpulse = appliedImpulse;
193  }
196  {
197  return m_appliedImpulse;
198  }
199 
200 
202  {
203  return m_breakingImpulseThreshold;
204  }
205 
207  {
208  m_breakingImpulseThreshold = threshold;
209  }
210 
211  bool isEnabled() const
212  {
213  return m_isEnabled;
214  }
215 
216  void setEnabled(bool enabled)
217  {
218  m_isEnabled=enabled;
219  }
220 
221 
223  virtual void solveConstraintObsolete(btSolverBody& /*bodyA*/,btSolverBody& /*bodyB*/,btScalar /*timeStep*/) {};
224 
225 
226  const btRigidBody& getRigidBodyA() const
227  {
228  return m_rbA;
229  }
230  const btRigidBody& getRigidBodyB() const
231  {
232  return m_rbB;
233  }
234 
236  {
237  return m_rbA;
238  }
240  {
241  return m_rbB;
242  }
243 
245  {
246  return m_userConstraintType ;
247  }
248 
249  void setUserConstraintType(int userConstraintType)
250  {
251  m_userConstraintType = userConstraintType;
252  };
253 
254  void setUserConstraintId(int uid)
255  {
256  m_userConstraintId = uid;
257  }
258 
260  {
261  return m_userConstraintId;
262  }
263 
264  void setUserConstraintPtr(void* ptr)
265  {
266  m_userConstraintPtr = ptr;
267  }
268 
270  {
271  return m_userConstraintPtr;
272  }
273 
274  void setJointFeedback(btJointFeedback* jointFeedback)
275  {
276  m_jointFeedback = jointFeedback;
277  }
278 
280  {
281  return m_jointFeedback;
282  }
283 
285  {
286  return m_jointFeedback;
287  }
288 
289 
290  int getUid() const
291  {
292  return m_userConstraintId;
293  }
294 
295  bool needsFeedback() const
296  {
297  return m_needsFeedback;
298  }
299 
302  void enableFeedback(bool needsFeedback)
303  {
304  m_needsFeedback = needsFeedback;
305  }
306 
310  {
311  btAssert(m_needsFeedback);
312  return m_appliedImpulse;
313  }
314 
316  {
317  return btTypedConstraintType(m_objectType);
318  }
319 
320  void setDbgDrawSize(btScalar dbgDrawSize)
321  {
322  m_dbgDrawSize = dbgDrawSize;
323  }
325  {
326  return m_dbgDrawSize;
327  }
328 
331  virtual void setParam(int num, btScalar value, int axis = -1) = 0;
332 
334  virtual btScalar getParam(int num, int axis = -1) const = 0;
335 
336  virtual int calculateSerializeBufferSize() const;
337 
339  virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
340 
341 };
342 
343 // returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits
344 // all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI])
345 SIMD_FORCE_INLINE btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
346 {
347  if(angleLowerLimitInRadians >= angleUpperLimitInRadians)
348  {
349  return angleInRadians;
350  }
351  else if(angleInRadians < angleLowerLimitInRadians)
352  {
353  btScalar diffLo = btFabs(btNormalizeAngle(angleLowerLimitInRadians - angleInRadians));
354  btScalar diffHi = btFabs(btNormalizeAngle(angleUpperLimitInRadians - angleInRadians));
355  return (diffLo < diffHi) ? angleInRadians : (angleInRadians + SIMD_2_PI);
356  }
357  else if(angleInRadians > angleUpperLimitInRadians)
358  {
359  btScalar diffHi = btFabs(btNormalizeAngle(angleInRadians - angleUpperLimitInRadians));
360  btScalar diffLo = btFabs(btNormalizeAngle(angleInRadians - angleLowerLimitInRadians));
361  return (diffLo < diffHi) ? (angleInRadians - SIMD_2_PI) : angleInRadians;
362  }
363  else
364  {
365  return angleInRadians;
366  }
367 }
368 
371 {
374  char *m_name;
375 
380 
383 
386 
389 
390 };
391 
393 
394 #define BT_BACKWARDS_COMPATIBLE_SERIALIZATION
395 #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION
398 {
401  char *m_name;
402 
407 
410 
413 
416 
417 };
418 #endif //BACKWARDS_COMPATIBLE
419 
421 {
424  char *m_name;
425 
430 
433 
436 
439  char padding[4];
440 
441 };
442 
443 
445 {
446  return sizeof(btTypedConstraintData2);
447 }
448 
449 
450 
452 {
453 private:
454  btScalar
455  m_center,
456  m_halfRange,
457  m_softness,
458  m_biasFactor,
459  m_relaxationFactor,
460  m_correction,
461  m_sign;
462 
463  bool
465 
466 public:
469  :m_center(0.0f),
470  m_halfRange(-1.0f),
471  m_softness(0.9f),
472  m_biasFactor(0.3f),
473  m_relaxationFactor(1.0f),
474  m_correction(0.0f),
475  m_sign(0.0f),
476  m_solveLimit(false)
477  {}
478 
482  void set(btScalar low, btScalar high, btScalar _softness = 0.9f, btScalar _biasFactor = 0.3f, btScalar _relaxationFactor = 1.0f);
483 
486  void test(const btScalar angle);
487 
489  inline btScalar getSoftness() const
490  {
491  return m_softness;
492  }
493 
495  inline btScalar getBiasFactor() const
496  {
497  return m_biasFactor;
498  }
499 
502  {
503  return m_relaxationFactor;
504  }
505 
507  inline btScalar getCorrection() const
508  {
509  return m_correction;
510  }
511 
513  inline btScalar getSign() const
514  {
515  return m_sign;
516  }
517 
519  inline btScalar getHalfRange() const
520  {
521  return m_halfRange;
522  }
523 
525  inline bool isLimit() const
526  {
527  return m_solveLimit;
528  }
529 
532  void fit(btScalar& angle) const;
533 
535  btScalar getError() const;
536 
537  btScalar getLow() const;
538 
539  btScalar getHigh() const;
540 
541 };
542 
543 
544 
545 #endif //BT_TYPED_CONSTRAINT_H
void enableFeedback(bool needsFeedback)
enableFeedback will allow to read the applied linear and angular impulse use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information
btRigidBodyFloatData * m_rbB
btRigidBodyData * m_rbB
int getUserConstraintType() const
btTypedConstraintType getConstraintType() const
void setUserConstraintPtr(void *ptr)
void setJointFeedback(btJointFeedback *jointFeedback)
bool isLimit() const
Returns true when the last test() invocation recognized limit violation.
#define btAssert(x)
Definition: btScalar.h:113
btRigidBodyData * m_rbA
btScalar getBreakingImpulseThreshold() const
#define SIMD_FORCE_INLINE
Definition: btScalar.h:63
void setUserConstraintId(int uid)
#define btRigidBodyData
Definition: btRigidBody.h:36
btJointFeedback * m_jointFeedback
int getUserConstraintId() const
btVector3 m_appliedForceBodyB
const btJointFeedback * getJointFeedback() const
void setBreakingImpulseThreshold(btScalar threshold)
btScalar m_breakingImpulseThreshold
void setDbgDrawSize(btScalar dbgDrawSize)
btTypedConstraint & operator=(btTypedConstraint &other)
btScalar getHalfRange() const
Gives half of the distance between min and max limit angle.
#define SIMD_2_PI
Definition: btScalar.h:477
bool needsFeedback() const
btVector3 m_appliedForceBodyA
btScalar getSign() const
Returns sign value evaluated when test() was invoked.
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btRigidBody.h:587
btScalar getSoftness() const
Returns limit&#39;s softness.
void setOverrideNumSolverIterations(int overideNumIterations)
override the number of constraint solver iterations used to solve this constraint -1 will use the def...
btScalar getBiasFactor() const
Returns limit&#39;s bias factor.
virtual ~btTypedConstraint()
#define btTypedConstraintData2
The btRigidBody is the main class for rigid body objects.
Definition: btRigidBody.h:62
btTypedConstraintType
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
Definition: btRigidBody.h:561
this structure is not used, except for loading pre-2.82 .bullet files
bool isEnabled() const
btScalar btAdjustAngleToLimits(btScalar angleInRadians, btScalar angleLowerLimitInRadians, btScalar angleUpperLimitInRadians)
btRigidBodyDoubleData * m_rbA
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:64
void setUserConstraintType(int userConstraintType)
btScalar btNormalizeAngle(btScalar angleInRadians)
Definition: btScalar.h:724
virtual void solveConstraintObsolete(btSolverBody &, btSolverBody &, btScalar)
internal method used by the constraint solver, don&#39;t use them directly
rudimentary class to provide type info
Definition: btScalar.h:744
btVector3 m_appliedTorqueBodyB
The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packe...
Definition: btSolverBody.h:108
btScalar getRelaxationFactor() const
Returns limit&#39;s relaxation factor.
virtual void setupSolverConstraint(btConstraintArray &ca, int solverBodyA, int solverBodyB, btScalar timeStep)
internal method used by the constraint solver, don&#39;t use them directly
TypedConstraint is the baseclass for Bullet constraints and vehicles.
btScalar internalGetAppliedImpulse()
internal method used by the constraint solver, don&#39;t use them directly
const btRigidBody & getRigidBodyA() const
void setEnabled(bool enabled)
#define BT_DECLARE_ALIGNED_ALLOCATOR()
Definition: btScalar.h:388
virtual int calculateSerializeBufferSize() const
btRigidBody & getRigidBodyB()
btVector3 m_appliedTorqueBodyA
btScalar getCorrection() const
Returns correction value evaluated when test() was invoked.
btRigidBodyFloatData * m_rbA
btAngularLimit()
Default constructor initializes limit as inactive, allowing free constraint movement.
btScalar getAppliedImpulse() const
getAppliedImpulse is an estimated total applied impulse.
btConstraintParams
void internalSetAppliedImpulse(btScalar appliedImpulse)
internal method used by the constraint solver, don&#39;t use them directly
btRigidBody & getRigidBodyA()
const btRigidBody & getRigidBodyB() const
int getOverrideNumSolverIterations() const
virtual void buildJacobian()
internal method used by the constraint solver, don&#39;t use them directly
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:278
btRigidBodyDoubleData * m_rbB
btJointFeedback * getJointFeedback()
btScalar btFabs(btScalar x)
Definition: btScalar.h:449