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 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/*
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
42
43
44class btRigidBody;
45
46
47
48#define SLIDER_CONSTRAINT_DEF_SOFTNESS (btScalar(1.0))
49#define SLIDER_CONSTRAINT_DEF_DAMPING (btScalar(1.0))
50#define SLIDER_CONSTRAINT_DEF_RESTITUTION (btScalar(0.7))
51#define SLIDER_CONSTRAINT_DEF_CFM (btScalar(0.f))
52
53
55{
68};
69
70
72{
73protected:
79 // use frameA fo define limits, if true
81 // linear limits
84 // angular limits
87 // softness, restitution and damping for different cases
88 // DirLin - moving inside linear limits
89 // LimLin - hitting linear limit
90 // DirAng - moving inside angular limits
91 // LimAng - hitting angular limit
92 // OrthoLin, OrthoAng - against constraint axis
97
102
107
112
117
122
123 // for interlal use
126
128
129 btJacobianEntry m_jacLin[3];
130 btScalar m_jacLinDiagABInv[3];
131
132 btJacobianEntry m_jacAng[3];
133
137
146
149
152
157
162
163 //------------------------
164 void initParams();
165public:
167
168 // constructors
169 btSliderConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
170 btSliderConstraint(btRigidBody& rbB, const btTransform& frameInB, bool useLinearReferenceFrameA);
171
172 // overrides
173
174 virtual void getInfo1 (btConstraintInfo1* info);
175
176 void getInfo1NonVirtual(btConstraintInfo1* info);
177
178 virtual void getInfo2 (btConstraintInfo2* info);
179
180 void getInfo2NonVirtual(btConstraintInfo2* info, const btTransform& transA, const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB, btScalar rbAinvMass,btScalar rbBinvMass);
181
182
183 // access
184 const btRigidBody& getRigidBodyA() const { return m_rbA; }
185 const btRigidBody& getRigidBodyB() const { return m_rbB; }
186 const btTransform & getCalculatedTransformA() const { return m_calculatedTransformA; }
187 const btTransform & getCalculatedTransformB() const { return m_calculatedTransformB; }
188 const btTransform & getFrameOffsetA() const { return m_frameInA; }
189 const btTransform & getFrameOffsetB() const { return m_frameInB; }
190 btTransform & getFrameOffsetA() { return m_frameInA; }
191 btTransform & getFrameOffsetB() { return m_frameInB; }
192 btScalar getLowerLinLimit() { return m_lowerLinLimit; }
193 void setLowerLinLimit(btScalar lowerLimit) { m_lowerLinLimit = lowerLimit; }
194 btScalar getUpperLinLimit() { return m_upperLinLimit; }
195 void setUpperLinLimit(btScalar upperLimit) { m_upperLinLimit = upperLimit; }
196 btScalar getLowerAngLimit() { return m_lowerAngLimit; }
197 void setLowerAngLimit(btScalar lowerLimit) { m_lowerAngLimit = btNormalizeAngle(lowerLimit); }
198 btScalar getUpperAngLimit() { return m_upperAngLimit; }
199 void setUpperAngLimit(btScalar upperLimit) { m_upperAngLimit = btNormalizeAngle(upperLimit); }
200 bool getUseLinearReferenceFrameA() { return m_useLinearReferenceFrameA; }
201 btScalar getSoftnessDirLin() { return m_softnessDirLin; }
202 btScalar getRestitutionDirLin() { return m_restitutionDirLin; }
203 btScalar getDampingDirLin() { return m_dampingDirLin ; }
204 btScalar getSoftnessDirAng() { return m_softnessDirAng; }
205 btScalar getRestitutionDirAng() { return m_restitutionDirAng; }
206 btScalar getDampingDirAng() { return m_dampingDirAng; }
207 btScalar getSoftnessLimLin() { return m_softnessLimLin; }
208 btScalar getRestitutionLimLin() { return m_restitutionLimLin; }
209 btScalar getDampingLimLin() { return m_dampingLimLin; }
210 btScalar getSoftnessLimAng() { return m_softnessLimAng; }
211 btScalar getRestitutionLimAng() { return m_restitutionLimAng; }
212 btScalar getDampingLimAng() { return m_dampingLimAng; }
213 btScalar getSoftnessOrthoLin() { return m_softnessOrthoLin; }
214 btScalar getRestitutionOrthoLin() { return m_restitutionOrthoLin; }
215 btScalar getDampingOrthoLin() { return m_dampingOrthoLin; }
216 btScalar getSoftnessOrthoAng() { return m_softnessOrthoAng; }
217 btScalar getRestitutionOrthoAng() { return m_restitutionOrthoAng; }
218 btScalar getDampingOrthoAng() { return m_dampingOrthoAng; }
219 void setSoftnessDirLin(btScalar softnessDirLin) { m_softnessDirLin = softnessDirLin; }
220 void setRestitutionDirLin(btScalar restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; }
221 void setDampingDirLin(btScalar dampingDirLin) { m_dampingDirLin = dampingDirLin; }
222 void setSoftnessDirAng(btScalar softnessDirAng) { m_softnessDirAng = softnessDirAng; }
223 void setRestitutionDirAng(btScalar restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; }
224 void setDampingDirAng(btScalar dampingDirAng) { m_dampingDirAng = dampingDirAng; }
225 void setSoftnessLimLin(btScalar softnessLimLin) { m_softnessLimLin = softnessLimLin; }
226 void setRestitutionLimLin(btScalar restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; }
227 void setDampingLimLin(btScalar dampingLimLin) { m_dampingLimLin = dampingLimLin; }
228 void setSoftnessLimAng(btScalar softnessLimAng) { m_softnessLimAng = softnessLimAng; }
229 void setRestitutionLimAng(btScalar restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; }
230 void setDampingLimAng(btScalar dampingLimAng) { m_dampingLimAng = dampingLimAng; }
231 void setSoftnessOrthoLin(btScalar softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; }
232 void setRestitutionOrthoLin(btScalar restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; }
233 void setDampingOrthoLin(btScalar dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; }
234 void setSoftnessOrthoAng(btScalar softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; }
235 void setRestitutionOrthoAng(btScalar restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; }
236 void setDampingOrthoAng(btScalar dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; }
237 void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; }
238 bool getPoweredLinMotor() { return m_poweredLinMotor; }
239 void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; }
240 btScalar getTargetLinMotorVelocity() { return m_targetLinMotorVelocity; }
241 void setMaxLinMotorForce(btScalar maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; }
242 btScalar getMaxLinMotorForce() { return m_maxLinMotorForce; }
243 void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; }
244 bool getPoweredAngMotor() { return m_poweredAngMotor; }
245 void setTargetAngMotorVelocity(btScalar targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; }
246 btScalar getTargetAngMotorVelocity() { return m_targetAngMotorVelocity; }
247 void setMaxAngMotorForce(btScalar maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; }
248 btScalar getMaxAngMotorForce() { return m_maxAngMotorForce; }
249
250 btScalar getLinearPos() const { return m_linPos; }
251 btScalar getAngularPos() const { return m_angPos; }
252
253
254
255 // access for ODE solver
256 bool getSolveLinLimit() { return m_solveLinLim; }
257 btScalar getLinDepth() { return m_depth[0]; }
258 bool getSolveAngLimit() { return m_solveAngLim; }
259 btScalar getAngDepth() { return m_angDepth; }
260 // shared code used by ODE solver
261 void calculateTransforms(const btTransform& transA,const btTransform& transB);
262 void testLinLimits();
263 void testAngLimits();
264 // access for PE Solver
265 btVector3 getAncorInA();
266 btVector3 getAncorInB();
267 // access for UseFrameOffset
268 bool getUseFrameOffset() { return m_useOffsetForConstraintFrame; }
269 void setUseFrameOffset(bool frameOffsetOnOff) { m_useOffsetForConstraintFrame = frameOffsetOnOff; }
270
271 void setFrames(const btTransform& frameA, const btTransform& frameB)
272 {
273 m_frameInA=frameA;
274 m_frameInB=frameB;
275 calculateTransforms(m_rbA.getCenterOfMassTransform(),m_rbB.getCenterOfMassTransform());
276 buildJacobian();
277 }
278
279
282 virtual void setParam(int num, btScalar value, int axis = -1);
284 virtual btScalar getParam(int num, int axis = -1) const;
285
286 virtual int getFlags() const
287 {
288 return m_flags;
289 }
290
291 virtual int calculateSerializeBufferSize() const;
292
294 virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
295
296
297};
298
299
301
302
304{
306 btTransformFloatData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
308
311
314
317
318};
319
320
322{
324 btTransformDoubleData m_rbAFrame; // constraint axii. Assumes z is hinge axis.
326
329
332
335
336};
337
339{
340 return sizeof(btSliderConstraintData2);
341}
342
344SIMD_FORCE_INLINE const char* btSliderConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
345{
346
347 btSliderConstraintData2* sliderData = (btSliderConstraintData2*) dataBuffer;
348 btTypedConstraint::serialize(&sliderData->m_typeConstraintData,serializer);
349
350 m_frameInA.serialize(sliderData->m_rbAFrame);
351 m_frameInB.serialize(sliderData->m_rbBFrame);
352
353 sliderData->m_linearUpperLimit = m_upperLinLimit;
354 sliderData->m_linearLowerLimit = m_lowerLinLimit;
355
356 sliderData->m_angularUpperLimit = m_upperAngLimit;
357 sliderData->m_angularLowerLimit = m_lowerAngLimit;
358
359 sliderData->m_useLinearReferenceFrameA = m_useLinearReferenceFrameA;
360 sliderData->m_useOffsetForConstraintFrame = m_useOffsetForConstraintFrame;
361
363}
364
365
366
367#endif //BT_SLIDER_CONSTRAINT_H
368
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
#define SIMD_FORCE_INLINE
Definition: btScalar.h:81
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:63
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)
btScalar getRestitutionDirAng()
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)
void setMaxAngMotorForce(btScalar maxAngMotorForce)
void setTargetLinMotorVelocity(btScalar targetLinMotorVelocity)
btScalar getRestitutionLimAng()
void setLowerLinLimit(btScalar lowerLimit)
void setSoftnessOrthoLin(btScalar softnessOrthoLin)
virtual int getFlags() const
btTransform m_calculatedTransformB
const btTransform & getCalculatedTransformB() const
btTransform m_calculatedTransformA
void setDampingOrthoAng(btScalar dampingOrthoAng)
btScalar getSoftnessOrthoAng()
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
btScalar getRestitutionLimLin()
void setSoftnessLimAng(btScalar softnessLimAng)
void setSoftnessDirLin(btScalar softnessDirLin)
const btTransform & getFrameOffsetA() const
btScalar getRestitutionOrthoAng()
void setFrames(const btTransform &frameA, const btTransform &frameB)
void setRestitutionDirLin(btScalar restitutionDirLin)
btScalar m_accumulatedLinMotorImpulse
btScalar getAngularPos() const
btScalar getTargetAngMotorVelocity()
btScalar m_accumulatedAngMotorImpulse
void setDampingDirLin(btScalar dampingDirLin)
btScalar getMaxAngMotorForce()
btScalar getRestitutionDirLin()
void setRestitutionOrthoAng(btScalar restitutionOrthoAng)
btTransform & getFrameOffsetB()
void setMaxLinMotorForce(btScalar maxLinMotorForce)
void setUpperAngLimit(btScalar upperLimit)
btScalar getSoftnessOrthoLin()
void setRestitutionLimAng(btScalar restitutionLimAng)
btScalar getMaxLinMotorForce()
void setLowerAngLimit(btScalar lowerLimit)
void setDampingLimLin(btScalar dampingLimLin)
void setDampingOrthoLin(btScalar dampingOrthoLin)
bool m_useSolveConstraintObsolete
for backwards compatibility during the transition to 'getInfo/getInfo2'
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
void serialize(struct btTransformData &dataOut) const
Definition: btTransform.h:267
TypedConstraint is the baseclass for Bullet constraints and vehicles.
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:84
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:254
this structure is not used, except for loading pre-2.82 .bullet files