Blender  V3.3
btSliderConstraint.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 Added by Roman Ponomarev (rponom@gmail.com)
18 April 04, 2008
19 
20 TODO:
21  - add clamping od accumulated impulse to improve stability
22  - add conversion for ODE constraint solver
23 */
24 
25 #ifndef BT_SLIDER_CONSTRAINT_H
26 #define BT_SLIDER_CONSTRAINT_H
27 
28 #include "LinearMath/btScalar.h" //for BT_USE_DOUBLE_PRECISION
29 
30 #ifdef BT_USE_DOUBLE_PRECISION
31 #define btSliderConstraintData2 btSliderConstraintDoubleData
32 #define btSliderConstraintDataName "btSliderConstraintDoubleData"
33 #else
34 #define btSliderConstraintData2 btSliderConstraintData
35 #define btSliderConstraintDataName "btSliderConstraintData"
36 #endif //BT_USE_DOUBLE_PRECISION
37 
38 #include "LinearMath/btVector3.h"
39 #include "btJacobianEntry.h"
40 #include "btTypedConstraint.h"
41 
42 class btRigidBody;
43 
44 #define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))
45 #define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))
46 #define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))
47 #define SLIDER_CONSTRAINT_DEF_CFM (btScalar(0.f))
48 
50 {
62  BT_SLIDER_FLAGS_ERP_LIMANG = (1 << 11)
63 };
64 
67 {
68 protected:
74  // use frameA fo define limits, if true
76  // linear limits
79  // angular limits
82  // softness, restitution and damping for different cases
83  // DirLin - moving inside linear limits
84  // LimLin - hitting linear limit
85  // DirAng - moving inside angular limits
86  // LimAng - hitting angular limit
87  // OrthoLin, OrthoAng - against constraint axis
92 
97 
102 
107 
112 
117 
118  // for interlal use
121 
122  int m_flags;
123 
126 
128 
132 
141 
144 
147 
152 
157 
158  //------------------------
159  void initParams();
160 
161 public:
163 
164  // constructors
165  btSliderConstraint(btRigidBody & rbA, btRigidBody & rbB, const btTransform& frameInA, const btTransform& frameInB, bool useLinearReferenceFrameA);
166  btSliderConstraint(btRigidBody & rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
167 
168  // overrides
169 
170  virtual void getInfo1(btConstraintInfo1 * info);
171 
173 
174  virtual void getInfo2(btConstraintInfo2 * info);
175 
176  void getInfo2NonVirtual(btConstraintInfo2 * info, const btTransform& transA, const btTransform& transB, const btVector3& linVelA, const btVector3& linVelB, btScalar rbAinvMass, btScalar rbBinvMass);
177 
178  // access
179  const btRigidBody& getRigidBodyA() const { return m_rbA; }
180  const btRigidBody& getRigidBodyB() const { return m_rbB; }
183  const btTransform& getFrameOffsetA() const { return m_frameInA; }
184  const btTransform& getFrameOffsetB() const { return m_frameInB; }
185  btTransform& getFrameOffsetA() { return m_frameInA; }
186  btTransform& getFrameOffsetB() { return m_frameInB; }
188  void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLimit; }
190  void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLimit; }
192  void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = btNormalizeAngle(lowerLimit); }
194  void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = btNormalizeAngle(upperLimit); }
214  void setSoftnessDirLin(btScalar softnessDirLin) { m_softnessDirLin = softnessDirLin; }
215  void setRestitutionDirLin(btScalar restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; }
216  void setDampingDirLin(btScalar dampingDirLin) { m_dampingDirLin = dampingDirLin; }
217  void setSoftnessDirAng(btScalar softnessDirAng) { m_softnessDirAng = softnessDirAng; }
218  void setRestitutionDirAng(btScalar restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; }
219  void setDampingDirAng(btScalar dampingDirAng) { m_dampingDirAng = dampingDirAng; }
220  void setSoftnessLimLin(btScalar softnessLimLin) { m_softnessLimLin = softnessLimLin; }
221  void setRestitutionLimLin(btScalar restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; }
222  void setDampingLimLin(btScalar dampingLimLin) { m_dampingLimLin = dampingLimLin; }
223  void setSoftnessLimAng(btScalar softnessLimAng) { m_softnessLimAng = softnessLimAng; }
224  void setRestitutionLimAng(btScalar restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; }
225  void setDampingLimAng(btScalar dampingLimAng) { m_dampingLimAng = dampingLimAng; }
226  void setSoftnessOrthoLin(btScalar softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; }
227  void setRestitutionOrthoLin(btScalar restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; }
228  void setDampingOrthoLin(btScalar dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; }
229  void setSoftnessOrthoAng(btScalar softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; }
230  void setRestitutionOrthoAng(btScalar restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; }
231  void setDampingOrthoAng(btScalar dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; }
232  void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; }
234  void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; }
236  void setMaxLinMotorForce(btScalar maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; }
238  void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; }
240  void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; }
242  void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
244 
245  btScalar getLinearPos() const { return m_linPos; }
246  btScalar getAngularPos() const { return m_angPos; }
247 
248  // access for ODE solver
249  bool getSolveLinLimit() { return m_solveLinLim; }
250  btScalar getLinDepth() { return m_depth[0]; }
251  bool getSolveAngLimit() { return m_solveAngLim; }
253  // shared code used by ODE solver
254  void calculateTransforms(const btTransform& transA, const btTransform& transB);
255  void testLinLimits();
256  void testAngLimits();
257  // access for PE Solver
260  // access for UseFrameOffset
262  void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
263 
264  void setFrames(const btTransform& frameA, const btTransform& frameB)
265  {
266  m_frameInA = frameA;
267  m_frameInB = frameB;
269  buildJacobian();
270  }
271 
274  virtual void setParam(int num, btScalar value, int axis = -1);
276  virtual btScalar getParam(int num, int axis = -1) const;
277 
278  virtual int getFlags() const
279  {
280  return m_flags;
281  }
282 
283  virtual int calculateSerializeBufferSize() const;
284 
286  virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
287 };
288 
290 
292 {
294  btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
296 
299 
302 
305 };
306 
308 {
310  btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
312 
315 
318 
321 };
322 
324 {
325  return sizeof(btSliderConstraintData2);
326 }
327 
329 SIMD_FORCE_INLINE const char* btSliderConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
330 {
331  btSliderConstraintData2* sliderData = (btSliderConstraintData2*)dataBuffer;
332  btTypedConstraint::serialize(&sliderData->m_typeConstraintData, serializer);
333 
334  m_frameInA.serialize(sliderData->m_rbAFrame);
335  m_frameInB.serialize(sliderData->m_rbBFrame);
336 
337  sliderData->m_linearUpperLimit = m_upperLinLimit;
338  sliderData->m_linearLowerLimit = m_lowerLinLimit;
339 
340  sliderData->m_angularUpperLimit = m_upperAngLimit;
341  sliderData->m_angularLowerLimit = m_lowerAngLimit;
342 
343  sliderData->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA;
344  sliderData->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame;
345 
347 }
348 
349 #endif //BT_SLIDER_CONSTRAINT_H
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly
bool m_useSolveConstraintObsolete
btFixedConstraint btRigidBody & rbB
btFixedConstraint btRigidBody const btTransform & frameInA
btFixedConstraint btRigidBody const btTransform const btTransform & frameInB
btJacobianEntry
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
#define ATTRIBUTE_ALIGNED16(a)
Definition: btScalar.h:285
SIMD_FORCE_INLINE btScalar btNormalizeAngle(btScalar angleInRadians)
Definition: btScalar.h:781
#define SIMD_FORCE_INLINE
Definition: btScalar.h:280
btScalar m_dampingDirLin
const btTransform & getCalculatedTransformA() const
BT_DECLARE_ALIGNED_ALLOCATOR()
btVector3 getAncorInA()
virtual void getInfo2(btConstraintInfo2 *info)
btScalar getSoftnessDirAng()
const btTransform & getFrameOffsetA() const
btVector3 getAncorInB()
btScalar m_softnessOrthoLin
btScalar m_lowerAngLimit
void setRestitutionLimLin(btScalar restitutionLimLin)
void calculateTransforms(const btTransform &transA, const btTransform &transB)
btScalar getDampingLimLin()
btScalar getSoftnessLimAng()
void setRestitutionOrthoLin(btScalar restitutionOrthoLin)
void setSoftnessLimAng(btScalar softnessLimAng)
btTransform m_calculatedTransformB
btSliderFlags
@ BT_SLIDER_FLAGS_CFM_DIRANG
@ BT_SLIDER_FLAGS_ERP_LIMLIN
@ BT_SLIDER_FLAGS_CFM_DIRLIN
@ BT_SLIDER_FLAGS_ERP_DIRANG
@ BT_SLIDER_FLAGS_ERP_DIRLIN
@ BT_SLIDER_FLAGS_CFM_ORTANG
@ BT_SLIDER_FLAGS_CFM_ORTLIN
@ BT_SLIDER_FLAGS_ERP_ORTANG
@ BT_SLIDER_FLAGS_CFM_LIMANG
@ BT_SLIDER_FLAGS_ERP_ORTLIN
@ BT_SLIDER_FLAGS_CFM_LIMLIN
@ BT_SLIDER_FLAGS_ERP_LIMANG
virtual void setParam(int num, btScalar value, int axis=-1)
btScalar getLowerLinLimit()
btScalar getUpperLinLimit()
btScalar m_dampingOrthoAng
btScalar m_restitutionDirAng
virtual int calculateSerializeBufferSize() const
btScalar m_softnessDirLin
btJacobianEntry m_jacAng[3]
bool m_solveAngLim
btScalar m_softnessOrthoAng
btTransform m_frameInA
btVector3 m_depth
bool m_poweredLinMotor
btSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btScalar m_cfmDirLin
void setRestitutionLimAng(btScalar restitutionLimAng)
btScalar m_dampingLimLin
btScalar getRestitutionLimLin()
bool getSolveLinLimit()
void setLowerLinLimit(btScalar lowerLimit)
#define btSliderConstraintDataName
btScalar getRestitutionDirAng()
void setUseFrameOffset(bool frameOffsetOnOff)
btScalar m_restitutionLimLin
btVector3 m_sliderAxis
btScalar getLinearPos() const
#define btSliderConstraintData2
btScalar m_lowerLinLimit
virtual int getFlags() const
btScalar getRestitutionOrthoAng()
btScalar m_accumulatedLinMotorImpulse
btScalar m_maxLinMotorForce
btVector3 m_relPosB
btScalar getDampingDirAng()
void setPoweredAngMotor(bool onOff)
btScalar getRestitutionLimAng()
const btTransform & getFrameOffsetB() const
btVector3 m_realPivotAInW
bool getUseFrameOffset()
const btRigidBody & getRigidBodyA() const
btScalar getSoftnessDirLin()
btScalar getSoftnessOrthoAng()
btScalar getDampingDirLin()
void setSoftnessDirLin(btScalar softnessDirLin)
btScalar getRestitutionOrthoLin()
const btRigidBody & getRigidBodyB() const
virtual btScalar getParam(int num, int axis=-1) const
return the local value of parameter
btScalar getLinDepth()
btScalar getSoftnessOrthoLin()
bool m_useLinearReferenceFrameA
btScalar getMaxLinMotorForce()
btScalar getRestitutionDirLin()
void initParams()
const btTransform & getCalculatedTransformB() const
btScalar m_cfmOrthoLin
btScalar getAngDepth()
void setMaxLinMotorForce(btScalar maxLinMotorForce)
void setDampingOrthoLin(btScalar dampingOrthoLin)
void setPoweredLinMotor(bool onOff)
btVector3 m_projPivotInW
btScalar m_dampingLimAng
btScalar getDampingOrthoLin()
void setSoftnessLimLin(btScalar softnessLimLin)
void setRestitutionOrthoAng(btScalar restitutionOrthoAng)
void setLowerAngLimit(btScalar lowerLimit)
void setUpperAngLimit(btScalar upperLimit)
btScalar getMaxAngMotorForce()
void setMaxAngMotorForce(btScalar maxAngMotorForce)
void setDampingLimLin(btScalar dampingLimLin)
void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity)
void setFrames(const btTransform &frameA, const btTransform &frameB)
btScalar m_upperAngLimit
bool m_solveLinLim
btScalar getDampingOrthoAng()
btScalar m_restitutionLimAng
void setRestitutionDirLin(btScalar restitutionDirLin)
btTransform m_frameInB
btScalar m_jacLinDiagABInv[3]
btScalar m_kAngle
btScalar m_targetAngMotorVelocity
btScalar m_angDepth
void setDampingDirAng(btScalar dampingDirAng)
btJacobianEntry m_jacLin[3]
void setRestitutionDirAng(btScalar restitutionDirAng)
void getInfo1NonVirtual(btConstraintInfo1 *info)
btScalar m_angPos
btScalar m_softnessDirAng
btScalar m_maxAngMotorForce
btScalar m_timeStep
btScalar m_softnessLimAng
btScalar m_cfmLimAng
btScalar m_linPos
btScalar getAngularPos() const
void setUpperLinLimit(btScalar upperLimit)
virtual void getInfo1(btConstraintInfo1 *info)
btScalar m_restitutionDirLin
void setSoftnessDirAng(btScalar softnessDirAng)
btScalar m_accumulatedAngMotorImpulse
btScalar m_cfmDirAng
btScalar m_restitutionOrthoLin
btScalar m_dampingDirAng
void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity)
void testAngLimits()
btScalar m_upperLinLimit
int m_flags
btScalar getDampingLimAng()
btVector3 m_realPivotBInW
btScalar getUpperAngLimit()
btScalar getLowerAngLimit()
void setDampingOrthoAng(btScalar dampingOrthoAng)
bool getPoweredAngMotor()
void setDampingDirLin(btScalar dampingDirLin)
btScalar m_targetLinMotorVelocity
btVector3 m_relPosA
btScalar m_softnessLimLin
void setDampingLimAng(btScalar dampingLimAng)
bool getSolveAngLimit()
void getInfo2NonVirtual(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &linVelA, const btVector3 &linVelB, btScalar rbAinvMass, btScalar rbBinvMass)
btScalar getSoftnessLimLin()
bool getPoweredLinMotor()
void setSoftnessOrthoAng(btScalar softnessOrthoAng)
bool m_poweredAngMotor
btScalar m_dampingOrthoLin
btScalar m_cfmLimLin
btTransform m_calculatedTransformA
void setSoftnessOrthoLin(btScalar softnessOrthoLin)
void testLinLimits()
btVector3 m_delta
btScalar getTargetLinMotorVelocity()
bool m_useOffsetForConstraintFrame
btScalar m_restitutionOrthoAng
btScalar m_cfmOrthoAng
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btScalar getTargetAngMotorVelocity()
bool getUseLinearReferenceFrameA()
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:30
btRigidBody & m_rbA
btTypedConstraint(btTypedConstraintType type, btRigidBody &rbA)
btRigidBody & m_rbB
btVector3
btVector3 can be used to represent 3D points and vectors. It has an un-used w component to suit 16-by...
Definition: btVector3.h:82
const btTransform & getCenterOfMassTransform() const
Definition: btRigidBody.h:429
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
btTransformFloatData m_rbBFrame
btTypedConstraintData m_typeConstraintData
btTransformFloatData m_rbAFrame
btTransformDoubleData m_rbAFrame
btTypedConstraintDoubleData m_typeConstraintData
btTransformDoubleData m_rbBFrame
for serialization
Definition: btTransform.h:245
this structure is not used, except for loading pre-2.82 .bullet files