Bullet Collision Detection & Physics Library
btSliderConstraint.h
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org
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/*
17Added by Roman Ponomarev (rponom@gmail.com)
18April 04, 2008
19
20TODO:
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
39#include "btJacobianEntry.h"
40#include "btTypedConstraint.h"
41
42class 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
64
67{
68protected:
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
123
126
128
132
141
144
147
152
157
158 //------------------------
159 void initParams();
160
161public:
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; }
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
250 btScalar getLinDepth() { return m_depth[0]; }
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
258 btVector3 getAncorInA();
259 btVector3 getAncorInB();
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;
268 calculateTransforms(m_rbA.getCenterOfMassTransform(), m_rbB.getCenterOfMassTransform());
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
306
322
327
329SIMD_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
btScalar btNormalizeAngle(btScalar angleInRadians)
Definition btScalar.h:781
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:99
#define SIMD_FORCE_INLINE
Definition btScalar.h:98
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
#define btSliderConstraintDataName
#define btSliderConstraintData2
Jacobian entry is an abstraction that allows to describe constraints it can be used in combination wi...
The btRigidBody is the main class for rigid body objects.
Definition btRigidBody.h:60
virtual const char * serialize(void *dataBuffer, class btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual int calculateSerializeBufferSize() const
void setSoftnessOrthoAng(btScalar softnessOrthoAng)
void setPoweredLinMotor(bool onOff)
btScalar getTargetLinMotorVelocity()
void setRestitutionDirAng(btScalar restitutionDirAng)
const btTransform & getFrameOffsetB() const
void setRestitutionOrthoLin(btScalar restitutionOrthoLin)
void setUseFrameOffset(bool frameOffsetOnOff)
void setSoftnessLimLin(btScalar softnessLimLin)
const btRigidBody & getRigidBodyB() const
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btJacobianEntry m_jacLin[3]
void setMaxAngMotorForce(btScalar maxAngMotorForce)
void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity)
void setLowerLinLimit(btScalar lowerLimit)
void setSoftnessOrthoLin(btScalar softnessOrthoLin)
btJacobianEntry m_jacAng[3]
virtual int getFlags() const
btSliderConstraint(btRigidBody &rbA, btRigidBody &rbB, const btTransform &frameInA, const btTransform &frameInB, bool useLinearReferenceFrameA)
btTransform m_calculatedTransformB
const btTransform & getCalculatedTransformB() const
btTransform m_calculatedTransformA
void setDampingOrthoAng(btScalar dampingOrthoAng)
void setUpperLinLimit(btScalar upperLimit)
void setRestitutionLimLin(btScalar restitutionLimLin)
void setPoweredAngMotor(bool onOff)
virtual int calculateSerializeBufferSize() const
const btRigidBody & getRigidBodyA() const
btScalar getLinearPos() const
void setDampingLimAng(btScalar dampingLimAng)
void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity)
void setDampingDirAng(btScalar dampingDirAng)
void setSoftnessDirAng(btScalar softnessDirAng)
btTransform & getFrameOffsetA()
btScalar getRestitutionOrthoLin()
const btTransform & getCalculatedTransformA() const
void setSoftnessLimAng(btScalar softnessLimAng)
void setSoftnessDirLin(btScalar softnessDirLin)
const btTransform & getFrameOffsetA() const
btScalar getRestitutionOrthoAng()
virtual void getInfo2(btConstraintInfo2 *info)
internal method used by the constraint solver, don't use them directly
void setFrames(const btTransform &frameA, const btTransform &frameB)
void setRestitutionDirLin(btScalar restitutionDirLin)
btScalar m_accumulatedLinMotorImpulse
btScalar getAngularPos() const
btScalar getTargetAngMotorVelocity()
void calculateTransforms(const btTransform &transA, const btTransform &transB)
btScalar m_accumulatedAngMotorImpulse
virtual void getInfo1(btConstraintInfo1 *info)
internal method used by the constraint solver, don't use them directly
void setDampingDirLin(btScalar dampingDirLin)
void setRestitutionOrthoAng(btScalar restitutionOrthoAng)
btTransform & getFrameOffsetB()
void setMaxLinMotorForce(btScalar maxLinMotorForce)
void setUpperAngLimit(btScalar upperLimit)
void setRestitutionLimAng(btScalar restitutionLimAng)
void setLowerAngLimit(btScalar lowerLimit)
void getInfo2NonVirtual(btConstraintInfo2 *info, const btTransform &transA, const btTransform &transB, const btVector3 &linVelA, const btVector3 &linVelB, btScalar rbAinvMass, btScalar rbBinvMass)
void setDampingLimLin(btScalar dampingLimLin)
void setDampingOrthoLin(btScalar dampingOrthoLin)
bool m_useSolveConstraintObsolete
for backwards compatibility during the transition to 'getInfo/getInfo2'
void getInfo1NonVirtual(btConstraintInfo1 *info)
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition btTransform.h:30
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual void buildJacobian()
internal method used by the constraint solver, don't use them directly
btTypedConstraint(btTypedConstraintType type, btRigidBody &rbA)
btVector3 can be used to represent 3D points and vectors.
Definition btVector3.h:82
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
this structure is not used, except for loading pre-2.82 .bullet files