1 /*************************************************************************
3 * Open Dynamics Engine, Copyright (C) 2001, 2002 Russell L. Smith. *
4 * All rights reserved. Email: russ@q12.org Web: www.q12.org *
6 * This library is free software; you can redistribute it and/or *
7 * modify it under the terms of EITHER: *
8 * (1) The GNU Lesser General Public License as published by the Free *
9 * Software Foundation; either version 2.1 of the License, or (at *
10 * your option) any later version. The text of the GNU Lesser *
11 * General Public License is included with this library in the *
13 * (2) The BSD-style license that is included with this library in *
14 * the file LICENSE-BSD.TXT. *
16 * This library is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files *
19 * LICENSE.TXT and LICENSE-BSD.TXT for more details. *
21 *************************************************************************/
23 /* C++ interface for non-collision stuff */
26 #ifndef _ODE_ODECPP_H_
27 #define _ODE_ODECPP_H_
36 class dWorldSimpleIDContainer {
40 dWorldSimpleIDContainer(): _id(0) {}
41 ~dWorldSimpleIDContainer() { destroy(); }
51 class dWorldDynamicIDContainer: public dWorldSimpleIDContainer {
53 virtual ~dWorldDynamicIDContainer() {}
56 template <class dWorldTemplateBase>
57 class dWorldTemplate: public dWorldTemplateBase {
58 // intentionally undefined, don't use these
59 dWorldTemplate (const dWorldTemplate<dWorldTemplateBase> &);
60 void operator= (const dWorldTemplate<dWorldTemplateBase> &);
63 dWorldID get_id() const { return dWorldTemplateBase::_id; }
64 void set_id(dWorldID value) { dWorldTemplateBase::_id = value; }
68 { set_id(dWorldCreate()); }
72 operator dWorldID() const
75 void setGravity (dReal x, dReal y, dReal z)
76 { dWorldSetGravity (get_id(), x, y, z); }
77 void setGravity (const dVector3 g)
78 { setGravity (g[0], g[1], g[2]); }
79 void getGravity (dVector3 g) const
80 { dWorldGetGravity (get_id(), g); }
82 void setERP (dReal erp)
83 { dWorldSetERP(get_id(), erp); }
85 { return dWorldGetERP(get_id()); }
87 void setCFM (dReal cfm)
88 { dWorldSetCFM(get_id(), cfm); }
90 { return dWorldGetCFM(get_id()); }
92 void step (dReal stepsize)
93 { dWorldStep (get_id(), stepsize); }
95 void quickStep(dReal stepsize)
96 { dWorldQuickStep (get_id(), stepsize); }
97 void setQuickStepNumIterations(int num)
98 { dWorldSetQuickStepNumIterations (get_id(), num); }
99 int getQuickStepNumIterations() const
100 { return dWorldGetQuickStepNumIterations (get_id()); }
101 void setQuickStepW(dReal over_relaxation)
102 { dWorldSetQuickStepW (get_id(), over_relaxation); }
103 dReal getQuickStepW() const
104 { return dWorldGetQuickStepW (get_id()); }
106 void setAutoDisableLinearThreshold (dReal threshold)
107 { dWorldSetAutoDisableLinearThreshold (get_id(), threshold); }
108 dReal getAutoDisableLinearThreshold() const
109 { return dWorldGetAutoDisableLinearThreshold (get_id()); }
110 void setAutoDisableAngularThreshold (dReal threshold)
111 { dWorldSetAutoDisableAngularThreshold (get_id(), threshold); }
112 dReal getAutoDisableAngularThreshold() const
113 { return dWorldGetAutoDisableAngularThreshold (get_id()); }
114 void setAutoDisableSteps (int steps)
115 { dWorldSetAutoDisableSteps (get_id(), steps); }
116 int getAutoDisableSteps() const
117 { return dWorldGetAutoDisableSteps (get_id()); }
118 void setAutoDisableTime (dReal time)
119 { dWorldSetAutoDisableTime (get_id(), time); }
120 dReal getAutoDisableTime() const
121 { return dWorldGetAutoDisableTime (get_id()); }
122 void setAutoDisableFlag (int do_auto_disable)
123 { dWorldSetAutoDisableFlag (get_id(), do_auto_disable); }
124 int getAutoDisableFlag() const
125 { return dWorldGetAutoDisableFlag (get_id()); }
127 dReal getLinearDampingThreshold() const
128 { return dWorldGetLinearDampingThreshold(get_id()); }
129 void setLinearDampingThreshold(dReal threshold)
130 { dWorldSetLinearDampingThreshold(get_id(), threshold); }
131 dReal getAngularDampingThreshold() const
132 { return dWorldGetAngularDampingThreshold(get_id()); }
133 void setAngularDampingThreshold(dReal threshold)
134 { dWorldSetAngularDampingThreshold(get_id(), threshold); }
135 dReal getLinearDamping() const
136 { return dWorldGetLinearDamping(get_id()); }
137 void setLinearDamping(dReal scale)
138 { dWorldSetLinearDamping(get_id(), scale); }
139 dReal getAngularDamping() const
140 { return dWorldGetAngularDamping(get_id()); }
141 void setAngularDamping(dReal scale)
142 { dWorldSetAngularDamping(get_id(), scale); }
143 void setDamping(dReal linear_scale, dReal angular_scale)
144 { dWorldSetDamping(get_id(), linear_scale, angular_scale); }
146 dReal getMaxAngularSpeed() const
147 { return dWorldGetMaxAngularSpeed(get_id()); }
148 void setMaxAngularSpeed(dReal max_speed)
149 { dWorldSetMaxAngularSpeed(get_id(), max_speed); }
151 void setContactSurfaceLayer(dReal depth)
152 { dWorldSetContactSurfaceLayer (get_id(), depth); }
153 dReal getContactSurfaceLayer() const
154 { return dWorldGetContactSurfaceLayer (get_id()); }
156 void impulseToForce (dReal stepsize, dReal ix, dReal iy, dReal iz,
158 { dWorldImpulseToForce (get_id(), stepsize, ix, iy, iz, force); }
162 class dBodySimpleIDContainer {
166 dBodySimpleIDContainer(): _id(0) {}
167 ~dBodySimpleIDContainer() { destroy(); }
177 class dBodyDynamicIDContainer: public dBodySimpleIDContainer {
179 virtual ~dBodyDynamicIDContainer() {}
182 template <class dBodyTemplateBase, class dWorldTemplateBase>
183 class dBodyTemplate: public dBodyTemplateBase {
184 // intentionally undefined, don't use these
185 dBodyTemplate (const dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase> &);
186 void operator= (const dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase> &);
189 dBodyID get_id() const { return dBodyTemplateBase::_id; }
190 void set_id(dBodyID value) { dBodyTemplateBase::_id = value; }
192 void destroy() { dBodyTemplateBase::destroy(); }
197 dBodyTemplate (dWorldID world)
198 { set_id(dBodyCreate(world)); }
199 dBodyTemplate (dWorldTemplate<dWorldTemplateBase>& world)
200 { set_id(dBodyCreate(world.id())); }
202 void create (dWorldID world) {
204 set_id(dBodyCreate(world));
206 void create (dWorldTemplate<dWorldTemplateBase>& world) {
212 operator dBodyID() const
215 void setData (void *data)
216 { dBodySetData (get_id(), data); }
217 void *getData() const
218 { return dBodyGetData (get_id()); }
220 void setPosition (dReal x, dReal y, dReal z)
221 { dBodySetPosition (get_id(), x, y, z); }
222 void setPosition (const dVector3 p)
223 { setPosition(p[0], p[1], p[2]); }
225 void setRotation (const dMatrix3 R)
226 { dBodySetRotation (get_id(), R); }
227 void setQuaternion (const dQuaternion q)
228 { dBodySetQuaternion (get_id(), q); }
229 void setLinearVel (dReal x, dReal y, dReal z)
230 { dBodySetLinearVel (get_id(), x, y, z); }
231 void setLinearVel (const dVector3 v)
232 { setLinearVel(v[0], v[1], v[2]); }
233 void setAngularVel (dReal x, dReal y, dReal z)
234 { dBodySetAngularVel (get_id(), x, y, z); }
235 void setAngularVel (const dVector3 v)
236 { setAngularVel (v[0], v[1], v[2]); }
238 const dReal * getPosition() const
239 { return dBodyGetPosition (get_id()); }
240 const dReal * getRotation() const
241 { return dBodyGetRotation (get_id()); }
242 const dReal * getQuaternion() const
243 { return dBodyGetQuaternion (get_id()); }
244 const dReal * getLinearVel() const
245 { return dBodyGetLinearVel (get_id()); }
246 const dReal * getAngularVel() const
247 { return dBodyGetAngularVel (get_id()); }
249 void setMass (const dMass *mass)
250 { dBodySetMass (get_id(), mass); }
251 void setMass (const dMass &mass)
253 dMass getMass () const
254 { dMass mass; dBodyGetMass (get_id(), &mass); return mass; }
256 void addForce (dReal fx, dReal fy, dReal fz)
257 { dBodyAddForce (get_id(), fx, fy, fz); }
258 void addForce (const dVector3 f)
259 { addForce (f[0], f[1], f[2]); }
260 void addTorque (dReal fx, dReal fy, dReal fz)
261 { dBodyAddTorque (get_id(), fx, fy, fz); }
262 void addTorque (const dVector3 t)
263 { addTorque(t[0], t[1], t[2]); }
265 void addRelForce (dReal fx, dReal fy, dReal fz)
266 { dBodyAddRelForce (get_id(), fx, fy, fz); }
267 void addRelForce (const dVector3 f)
268 { addRelForce (f[0], f[1], f[2]); }
269 void addRelTorque (dReal fx, dReal fy, dReal fz)
270 { dBodyAddRelTorque (get_id(), fx, fy, fz); }
271 void addRelTorque (const dVector3 t)
272 { addRelTorque (t[0], t[1], t[2]); }
274 void addForceAtPos (dReal fx, dReal fy, dReal fz,
275 dReal px, dReal py, dReal pz)
276 { dBodyAddForceAtPos (get_id(), fx, fy, fz, px, py, pz); }
277 void addForceAtPos (const dVector3 f, const dVector3 p)
278 { addForceAtPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
280 void addForceAtRelPos (dReal fx, dReal fy, dReal fz,
281 dReal px, dReal py, dReal pz)
282 { dBodyAddForceAtRelPos (get_id(), fx, fy, fz, px, py, pz); }
283 void addForceAtRelPos (const dVector3 f, const dVector3 p)
284 { addForceAtRelPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
286 void addRelForceAtPos (dReal fx, dReal fy, dReal fz,
287 dReal px, dReal py, dReal pz)
288 { dBodyAddRelForceAtPos (get_id(), fx, fy, fz, px, py, pz); }
289 void addRelForceAtPos (const dVector3 f, const dVector3 p)
290 { addRelForceAtPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
292 void addRelForceAtRelPos (dReal fx, dReal fy, dReal fz,
293 dReal px, dReal py, dReal pz)
294 { dBodyAddRelForceAtRelPos (get_id(), fx, fy, fz, px, py, pz); }
295 void addRelForceAtRelPos (const dVector3 f, const dVector3 p)
296 { addRelForceAtRelPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
298 const dReal * getForce() const
299 { return dBodyGetForce(get_id()); }
300 const dReal * getTorque() const
301 { return dBodyGetTorque(get_id()); }
302 void setForce (dReal x, dReal y, dReal z)
303 { dBodySetForce (get_id(), x, y, z); }
304 void setForce (const dVector3 f)
305 { setForce (f[0], f[1], f[2]); }
306 void setTorque (dReal x, dReal y, dReal z)
307 { dBodySetTorque (get_id(), x, y, z); }
308 void setTorque (const dVector3 t)
309 { setTorque (t[0], t[1], t[2]); }
312 { dBodySetDynamic (get_id()); }
314 { dBodySetKinematic (get_id()); }
315 bool isKinematic() const
316 { return dBodyIsKinematic (get_id()) != 0; }
319 { dBodyEnable (get_id()); }
321 { dBodyDisable (get_id()); }
322 bool isEnabled() const
323 { return dBodyIsEnabled (get_id()) != 0; }
325 void getRelPointPos (dReal px, dReal py, dReal pz, dVector3 result) const
326 { dBodyGetRelPointPos (get_id(), px, py, pz, result); }
327 void getRelPointPos (const dVector3 p, dVector3 result) const
328 { getRelPointPos (p[0], p[1], p[2], result); }
330 void getRelPointVel (dReal px, dReal py, dReal pz, dVector3 result) const
331 { dBodyGetRelPointVel (get_id(), px, py, pz, result); }
332 void getRelPointVel (const dVector3 p, dVector3 result) const
333 { getRelPointVel (p[0], p[1], p[2], result); }
335 void getPointVel (dReal px, dReal py, dReal pz, dVector3 result) const
336 { dBodyGetPointVel (get_id(), px, py, pz, result); }
337 void getPointVel (const dVector3 p, dVector3 result) const
338 { getPointVel (p[0], p[1], p[2], result); }
340 void getPosRelPoint (dReal px, dReal py, dReal pz, dVector3 result) const
341 { dBodyGetPosRelPoint (get_id(), px, py, pz, result); }
342 void getPosRelPoint (const dVector3 p, dVector3 result) const
343 { getPosRelPoint (p[0], p[1], p[2], result); }
345 void vectorToWorld (dReal px, dReal py, dReal pz, dVector3 result) const
346 { dBodyVectorToWorld (get_id(), px, py, pz, result); }
347 void vectorToWorld (const dVector3 p, dVector3 result) const
348 { vectorToWorld (p[0], p[1], p[2], result); }
350 void vectorFromWorld (dReal px, dReal py, dReal pz, dVector3 result) const
351 { dBodyVectorFromWorld (get_id(), px, py, pz, result); }
352 void vectorFromWorld (const dVector3 p, dVector3 result) const
353 { vectorFromWorld (p[0], p[1], p[2], result); }
355 void setFiniteRotationMode (bool mode)
356 { dBodySetFiniteRotationMode (get_id(), mode); }
358 void setFiniteRotationAxis (dReal x, dReal y, dReal z)
359 { dBodySetFiniteRotationAxis (get_id(), x, y, z); }
360 void setFiniteRotationAxis (const dVector3 a)
361 { setFiniteRotationAxis (a[0], a[1], a[2]); }
363 bool getFiniteRotationMode() const
364 { return dBodyGetFiniteRotationMode (get_id()) != 0; }
365 void getFiniteRotationAxis (dVector3 result) const
366 { dBodyGetFiniteRotationAxis (get_id(), result); }
368 int getNumJoints() const
369 { return dBodyGetNumJoints (get_id()); }
370 dJointID getJoint (int index) const
371 { return dBodyGetJoint (get_id(), index); }
373 void setGravityMode (bool mode)
374 { dBodySetGravityMode (get_id(), mode); }
375 bool getGravityMode() const
376 { return dBodyGetGravityMode (get_id()) != 0; }
378 bool isConnectedTo (dBodyID body) const
379 { return dAreConnected (get_id(), body) != 0; }
381 void setAutoDisableLinearThreshold (dReal threshold)
382 { dBodySetAutoDisableLinearThreshold (get_id(), threshold); }
383 dReal getAutoDisableLinearThreshold() const
384 { return dBodyGetAutoDisableLinearThreshold (get_id()); }
385 void setAutoDisableAngularThreshold (dReal threshold)
386 { dBodySetAutoDisableAngularThreshold (get_id(), threshold); }
387 dReal getAutoDisableAngularThreshold() const
388 { return dBodyGetAutoDisableAngularThreshold (get_id()); }
389 void setAutoDisableSteps (int steps)
390 { dBodySetAutoDisableSteps (get_id(), steps); }
391 int getAutoDisableSteps() const
392 { return dBodyGetAutoDisableSteps (get_id()); }
393 void setAutoDisableTime (dReal time)
394 { dBodySetAutoDisableTime (get_id(), time); }
395 dReal getAutoDisableTime() const
396 { return dBodyGetAutoDisableTime (get_id()); }
397 void setAutoDisableFlag (bool do_auto_disable)
398 { dBodySetAutoDisableFlag (get_id(), do_auto_disable); }
399 bool getAutoDisableFlag() const
400 { return dBodyGetAutoDisableFlag (get_id()) != 0; }
402 dReal getLinearDamping() const
403 { return dBodyGetLinearDamping(get_id()); }
404 void setLinearDamping(dReal scale)
405 { dBodySetLinearDamping(get_id(), scale); }
406 dReal getAngularDamping() const
407 { return dBodyGetAngularDamping(get_id()); }
408 void setAngularDamping(dReal scale)
409 { dBodySetAngularDamping(get_id(), scale); }
410 void setDamping(dReal linear_scale, dReal angular_scale)
411 { dBodySetDamping(get_id(), linear_scale, angular_scale); }
412 dReal getLinearDampingThreshold() const
413 { return dBodyGetLinearDampingThreshold(get_id()); }
414 void setLinearDampingThreshold(dReal threshold) const
415 { dBodySetLinearDampingThreshold(get_id(), threshold); }
416 dReal getAngularDampingThreshold() const
417 { return dBodyGetAngularDampingThreshold(get_id()); }
418 void setAngularDampingThreshold(dReal threshold)
419 { dBodySetAngularDampingThreshold(get_id(), threshold); }
420 void setDampingDefaults()
421 { dBodySetDampingDefaults(get_id()); }
423 dReal getMaxAngularSpeed() const
424 { return dBodyGetMaxAngularSpeed(get_id()); }
425 void setMaxAngularSpeed(dReal max_speed)
426 { dBodySetMaxAngularSpeed(get_id(), max_speed); }
428 bool getGyroscopicMode() const
429 { return dBodyGetGyroscopicMode(get_id()) != 0; }
430 void setGyroscopicMode(bool mode)
431 { dBodySetGyroscopicMode(get_id(), mode); }
436 class dJointGroupSimpleIDContainer {
440 dJointGroupSimpleIDContainer(): _id(0) {}
441 ~dJointGroupSimpleIDContainer() { destroy(); }
445 dJointGroupDestroy(_id);
451 class dJointGroupDynamicIDContainer: public dJointGroupSimpleIDContainer {
453 virtual ~dJointGroupDynamicIDContainer() {}
456 template <class dJointGroupTemplateBase>
457 class dJointGroupTemplate: public dJointGroupTemplateBase {
458 // intentionally undefined, don't use these
459 dJointGroupTemplate (const dJointGroupTemplate<dJointGroupTemplateBase> &);
460 void operator= (const dJointGroupTemplate<dJointGroupTemplateBase> &);
463 dJointGroupID get_id() const { return dJointGroupTemplateBase::_id; }
464 void set_id(dJointGroupID value) { dJointGroupTemplateBase::_id = value; }
466 void destroy() { dJointGroupTemplateBase::destroy(); }
469 dJointGroupTemplate ()
470 { set_id(dJointGroupCreate(0)); }
474 set_id(dJointGroupCreate(0));
477 dJointGroupID id() const
479 operator dJointGroupID() const
483 { dJointGroupEmpty (get_id()); }
489 class dJointSimpleIDContainer {
493 dJointSimpleIDContainer(): _id(0) {}
494 ~dJointSimpleIDContainer() { destroy(); }
504 class dJointDynamicIDContainer: public dJointSimpleIDContainer {
506 virtual ~dJointDynamicIDContainer() {}
509 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
510 class dJointTemplate: public dJointTemplateBase {
512 // intentionally undefined, don't use these
513 dJointTemplate (const dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &) ;
514 void operator= (const dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
517 dJointID get_id() const { return dJointTemplateBase::_id; }
518 void set_id(dJointID value) { dJointTemplateBase::_id = value; }
520 void destroy() { dJointTemplateBase::destroy(); }
523 dJointTemplate() // don't let user construct pure dJointTemplate objects
529 operator dJointID() const
532 int getNumBodies() const
533 { return dJointGetNumBodies(get_id()); }
535 void attach (dBodyID body1, dBodyID body2)
536 { dJointAttach (get_id(), body1, body2); }
537 void attach (dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase>& body1, dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase>& body2)
538 { attach(body1.id(), body2.id()); }
541 { dJointEnable (get_id()); }
543 { dJointDisable (get_id()); }
544 bool isEnabled() const
545 { return dJointIsEnabled (get_id()) != 0; }
547 void setData (void *data)
548 { dJointSetData (get_id(), data); }
549 void *getData() const
550 { return dJointGetData (get_id()); }
552 dJointType getType() const
553 { return dJointGetType (get_id()); }
555 dBodyID getBody (int index) const
556 { return dJointGetBody (get_id(), index); }
558 void setFeedback(dJointFeedback *fb)
559 { dJointSetFeedback(get_id(), fb); }
560 dJointFeedback *getFeedback() const
561 { return dJointGetFeedback(get_id()); }
563 // If not implemented it will do nothing as describe in the doc
564 virtual void setParam (int, dReal) {};
565 virtual dReal getParam (int) const { return 0; }
569 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
570 class dBallJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
572 // intentionally undefined, don't use these
573 dBallJointTemplate (const dBallJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
574 void operator= (const dBallJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
577 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
579 dJointID get_id() const { return dBaseTemplate::get_id(); }
580 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
582 void destroy() { dBaseTemplate::destroy(); }
585 dBallJointTemplate() { }
586 dBallJointTemplate (dWorldID world, dJointGroupID group=0)
587 { set_id(dJointCreateBall(world, group)); }
588 dBallJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
589 { set_id(dJointCreateBall(world.id(), group)); }
591 void create (dWorldID world, dJointGroupID group=0) {
593 set_id(dJointCreateBall(world, group));
595 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
596 { create(world.id(), group); }
598 void setAnchor (dReal x, dReal y, dReal z)
599 { dJointSetBallAnchor (get_id(), x, y, z); }
600 void setAnchor (const dVector3 a)
601 { setAnchor (a[0], a[1], a[2]); }
602 void getAnchor (dVector3 result) const
603 { dJointGetBallAnchor (get_id(), result); }
604 void getAnchor2 (dVector3 result) const
605 { dJointGetBallAnchor2 (get_id(), result); }
606 virtual void setParam (int parameter, dReal value)
607 { dJointSetBallParam (get_id(), parameter, value); }
608 virtual dReal getParam (int parameter) const
609 { return dJointGetBallParam (get_id(), parameter); }
610 // TODO: expose params through methods
614 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
615 class dHingeJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
617 // intentionally undefined, don't use these
618 dHingeJointTemplate (const dHingeJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
619 void operator = (const dHingeJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
622 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
624 dJointID get_id() const { return dBaseTemplate::get_id(); }
625 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
627 void destroy() { dBaseTemplate::destroy(); }
630 dHingeJointTemplate() { }
631 dHingeJointTemplate (dWorldID world, dJointGroupID group=0)
632 { set_id(dJointCreateHinge(world, group)); }
633 dHingeJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
634 { set_id(dJointCreateHinge(world.id(), group)); }
636 void create (dWorldID world, dJointGroupID group=0) {
638 set_id(dJointCreateHinge (world, group));
640 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
641 { create(world.id(), group); }
643 void setAnchor (dReal x, dReal y, dReal z)
644 { dJointSetHingeAnchor (get_id(), x, y, z); }
645 void setAnchor (const dVector3 a)
646 { setAnchor (a[0], a[1], a[2]); }
647 void getAnchor (dVector3 result) const
648 { dJointGetHingeAnchor (get_id(), result); }
649 void getAnchor2 (dVector3 result) const
650 { dJointGetHingeAnchor2 (get_id(), result); }
652 void setAxis (dReal x, dReal y, dReal z)
653 { dJointSetHingeAxis (get_id(), x, y, z); }
654 void setAxis (const dVector3 a)
655 { setAxis(a[0], a[1], a[2]); }
656 void getAxis (dVector3 result) const
657 { dJointGetHingeAxis (get_id(), result); }
659 dReal getAngle() const
660 { return dJointGetHingeAngle (get_id()); }
661 dReal getAngleRate() const
662 { return dJointGetHingeAngleRate (get_id()); }
664 virtual void setParam (int parameter, dReal value)
665 { dJointSetHingeParam (get_id(), parameter, value); }
666 virtual dReal getParam (int parameter) const
667 { return dJointGetHingeParam (get_id(), parameter); }
668 // TODO: expose params through methods
670 void addTorque (dReal torque)
671 { dJointAddHingeTorque(get_id(), torque); }
675 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
676 class dSliderJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
678 // intentionally undefined, don't use these
679 dSliderJointTemplate (const dSliderJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
680 void operator = (const dSliderJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
683 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
685 dJointID get_id() const { return dBaseTemplate::get_id(); }
686 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
688 void destroy() { dBaseTemplate::destroy(); }
691 dSliderJointTemplate() { }
692 dSliderJointTemplate (dWorldID world, dJointGroupID group=0)
693 { set_id(dJointCreateSlider(world, group)); }
694 dSliderJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
695 { set_id(dJointCreateSlider(world.id(), group)); }
697 void create (dWorldID world, dJointGroupID group=0) {
699 set_id(dJointCreateSlider(world, group));
701 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
702 { create(world.id(), group); }
704 void setAxis (dReal x, dReal y, dReal z)
705 { dJointSetSliderAxis (get_id(), x, y, z); }
706 void setAxis (const dVector3 a)
707 { setAxis (a[0], a[1], a[2]); }
708 void getAxis (dVector3 result) const
709 { dJointGetSliderAxis (get_id(), result); }
711 dReal getPosition() const
712 { return dJointGetSliderPosition (get_id()); }
713 dReal getPositionRate() const
714 { return dJointGetSliderPositionRate (get_id()); }
716 virtual void setParam (int parameter, dReal value)
717 { dJointSetSliderParam (get_id(), parameter, value); }
718 virtual dReal getParam (int parameter) const
719 { return dJointGetSliderParam (get_id(), parameter); }
720 // TODO: expose params through methods
722 void addForce (dReal force)
723 { dJointAddSliderForce(get_id(), force); }
727 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
728 class dUniversalJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
730 // intentionally undefined, don't use these
731 dUniversalJointTemplate (const dUniversalJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
732 void operator = (const dUniversalJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
735 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
737 dJointID get_id() const { return dBaseTemplate::get_id(); }
738 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
740 void destroy() { dBaseTemplate::destroy(); }
743 dUniversalJointTemplate() { }
744 dUniversalJointTemplate (dWorldID world, dJointGroupID group=0)
745 { set_id(dJointCreateUniversal(world, group)); }
746 dUniversalJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
747 { set_id(dJointCreateUniversal(world.id(), group)); }
749 void create (dWorldID world, dJointGroupID group=0) {
751 set_id(dJointCreateUniversal(world, group));
753 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
754 { create(world.id(), group); }
756 void setAnchor (dReal x, dReal y, dReal z)
757 { dJointSetUniversalAnchor (get_id(), x, y, z); }
758 void setAnchor (const dVector3 a)
759 { setAnchor(a[0], a[1], a[2]); }
760 void setAxis1 (dReal x, dReal y, dReal z)
761 { dJointSetUniversalAxis1 (get_id(), x, y, z); }
762 void setAxis1 (const dVector3 a)
763 { setAxis1 (a[0], a[1], a[2]); }
764 void setAxis2 (dReal x, dReal y, dReal z)
765 { dJointSetUniversalAxis2 (get_id(), x, y, z); }
766 void setAxis2 (const dVector3 a)
767 { setAxis2 (a[0], a[1], a[2]); }
769 void getAnchor (dVector3 result) const
770 { dJointGetUniversalAnchor (get_id(), result); }
771 void getAnchor2 (dVector3 result) const
772 { dJointGetUniversalAnchor2 (get_id(), result); }
773 void getAxis1 (dVector3 result) const
774 { dJointGetUniversalAxis1 (get_id(), result); }
775 void getAxis2 (dVector3 result) const
776 { dJointGetUniversalAxis2 (get_id(), result); }
778 virtual void setParam (int parameter, dReal value)
779 { dJointSetUniversalParam (get_id(), parameter, value); }
780 virtual dReal getParam (int parameter) const
781 { return dJointGetUniversalParam (get_id(), parameter); }
782 // TODO: expose params through methods
784 void getAngles(dReal *angle1, dReal *angle2) const
785 { dJointGetUniversalAngles (get_id(), angle1, angle2); }
787 dReal getAngle1() const
788 { return dJointGetUniversalAngle1 (get_id()); }
789 dReal getAngle1Rate() const
790 { return dJointGetUniversalAngle1Rate (get_id()); }
791 dReal getAngle2() const
792 { return dJointGetUniversalAngle2 (get_id()); }
793 dReal getAngle2Rate() const
794 { return dJointGetUniversalAngle2Rate (get_id()); }
796 void addTorques (dReal torque1, dReal torque2)
797 { dJointAddUniversalTorques(get_id(), torque1, torque2); }
801 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
802 class dHinge2JointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
804 // intentionally undefined, don't use these
805 dHinge2JointTemplate (const dHinge2JointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
806 void operator = (const dHinge2JointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
809 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
811 dJointID get_id() const { return dBaseTemplate::get_id(); }
812 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
814 void destroy() { dBaseTemplate::destroy(); }
817 dHinge2JointTemplate() { }
818 dHinge2JointTemplate (dWorldID world, dJointGroupID group=0)
819 { set_id(dJointCreateHinge2(world, group)); }
820 dHinge2JointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
821 { set_id(dJointCreateHinge2(world.id(), group)); }
823 void create (dWorldID world, dJointGroupID group=0) {
825 set_id(dJointCreateHinge2(world, group));
827 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
828 { create(world.id(), group); }
830 void setAnchor (dReal x, dReal y, dReal z)
831 { dJointSetHinge2Anchor (get_id(), x, y, z); }
832 void setAnchor (const dVector3 a)
833 { setAnchor(a[0], a[1], a[2]); }
834 void setAxis1 (dReal x, dReal y, dReal z)
835 { dJointSetHinge2Axis1 (get_id(), x, y, z); }
836 void setAxis1 (const dVector3 a)
837 { setAxis1 (a[0], a[1], a[2]); }
838 void setAxis2 (dReal x, dReal y, dReal z)
839 { dJointSetHinge2Axis2 (get_id(), x, y, z); }
840 void setAxis2 (const dVector3 a)
841 { setAxis2 (a[0], a[1], a[2]); }
843 void getAnchor (dVector3 result) const
844 { dJointGetHinge2Anchor (get_id(), result); }
845 void getAnchor2 (dVector3 result) const
846 { dJointGetHinge2Anchor2 (get_id(), result); }
847 void getAxis1 (dVector3 result) const
848 { dJointGetHinge2Axis1 (get_id(), result); }
849 void getAxis2 (dVector3 result) const
850 { dJointGetHinge2Axis2 (get_id(), result); }
852 dReal getAngle1() const
853 { return dJointGetHinge2Angle1 (get_id()); }
854 dReal getAngle1Rate() const
855 { return dJointGetHinge2Angle1Rate (get_id()); }
856 dReal getAngle2Rate() const
857 { return dJointGetHinge2Angle2Rate (get_id()); }
859 virtual void setParam (int parameter, dReal value)
860 { dJointSetHinge2Param (get_id(), parameter, value); }
861 virtual dReal getParam (int parameter) const
862 { return dJointGetHinge2Param (get_id(), parameter); }
863 // TODO: expose params through methods
865 void addTorques(dReal torque1, dReal torque2)
866 { dJointAddHinge2Torques(get_id(), torque1, torque2); }
870 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
871 class dPRJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
873 // intentionally undefined, don't use these
874 dPRJointTemplate (const dPRJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
875 void operator = (const dPRJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
878 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
880 dJointID get_id() const { return dBaseTemplate::get_id(); }
881 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
883 void destroy() { dBaseTemplate::destroy(); }
886 dPRJointTemplate() { }
887 dPRJointTemplate (dWorldID world, dJointGroupID group=0)
888 { set_id(dJointCreatePR(world, group)); }
889 dPRJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
890 { set_id(dJointCreatePR(world.id(), group)); }
892 void create (dWorldID world, dJointGroupID group=0) {
894 set_id(dJointCreatePR(world, group));
896 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
897 { create(world.id(), group); }
899 void setAnchor (dReal x, dReal y, dReal z)
900 { dJointSetPRAnchor (get_id(), x, y, z); }
901 void setAnchor (const dVector3 a)
902 { setAnchor (a[0], a[1], a[2]); }
903 void setAxis1 (dReal x, dReal y, dReal z)
904 { dJointSetPRAxis1 (get_id(), x, y, z); }
905 void setAxis1 (const dVector3 a)
906 { setAxis1(a[0], a[1], a[2]); }
907 void setAxis2 (dReal x, dReal y, dReal z)
908 { dJointSetPRAxis2 (get_id(), x, y, z); }
909 void setAxis2 (const dVector3 a)
910 { setAxis2(a[0], a[1], a[2]); }
912 void getAnchor (dVector3 result) const
913 { dJointGetPRAnchor (get_id(), result); }
914 void getAxis1 (dVector3 result) const
915 { dJointGetPRAxis1 (get_id(), result); }
916 void getAxis2 (dVector3 result) const
917 { dJointGetPRAxis2 (get_id(), result); }
919 dReal getPosition() const
920 { return dJointGetPRPosition (get_id()); }
921 dReal getPositionRate() const
922 { return dJointGetPRPositionRate (get_id()); }
924 dReal getAngle() const
925 { return dJointGetPRAngle (get_id()); }
926 dReal getAngleRate() const
927 { return dJointGetPRAngleRate (get_id()); }
929 virtual void setParam (int parameter, dReal value)
930 { dJointSetPRParam (get_id(), parameter, value); }
931 virtual dReal getParam (int parameter) const
932 { return dJointGetPRParam (get_id(), parameter); }
937 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
938 class dPUJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
941 // intentionally undefined, don't use these
942 dPUJointTemplate (const dPUJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
943 void operator = (const dPUJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
946 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
948 dJointID get_id() const { return dBaseTemplate::get_id(); }
949 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
951 void destroy() { dBaseTemplate::destroy(); }
954 dPUJointTemplate() { }
955 dPUJointTemplate (dWorldID world, dJointGroupID group=0)
956 { set_id(dJointCreatePU(world, group)); }
957 dPUJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
958 { set_id(dJointCreatePU(world.id(), group)); }
960 void create (dWorldID world, dJointGroupID group=0)
963 set_id(dJointCreatePU(world, group));
965 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
966 { create(world.id(), group); }
968 void setAnchor (dReal x, dReal y, dReal z)
969 { dJointSetPUAnchor (get_id(), x, y, z); }
970 void setAnchor (const dVector3 a)
971 { setAnchor (a[0], a[1], a[2]); }
972 void setAxis1 (dReal x, dReal y, dReal z)
973 { dJointSetPUAxis1 (get_id(), x, y, z); }
974 void setAxis1 (const dVector3 a)
975 { setAxis1(a[0], a[1], a[2]); }
976 void setAxis2 (dReal x, dReal y, dReal z)
977 { dJointSetPUAxis2 (get_id(), x, y, z); }
978 void setAxis3 (dReal x, dReal y, dReal z)
979 { dJointSetPUAxis3 (get_id(), x, y, z); }
980 void setAxis3 (const dVector3 a)
981 { setAxis3(a[0], a[1], a[2]); }
982 void setAxisP (dReal x, dReal y, dReal z)
983 { dJointSetPUAxis3 (get_id(), x, y, z); }
984 void setAxisP (const dVector3 a)
985 { setAxisP(a[0], a[1], a[2]); }
987 virtual void getAnchor (dVector3 result) const
988 { dJointGetPUAnchor (get_id(), result); }
989 void getAxis1 (dVector3 result) const
990 { dJointGetPUAxis1 (get_id(), result); }
991 void getAxis2 (dVector3 result) const
992 { dJointGetPUAxis2 (get_id(), result); }
993 void getAxis3 (dVector3 result) const
994 { dJointGetPUAxis3 (get_id(), result); }
995 void getAxisP (dVector3 result) const
996 { dJointGetPUAxis3 (get_id(), result); }
998 dReal getAngle1() const
999 { return dJointGetPUAngle1 (get_id()); }
1000 dReal getAngle1Rate() const
1001 { return dJointGetPUAngle1Rate (get_id()); }
1002 dReal getAngle2() const
1003 { return dJointGetPUAngle2 (get_id()); }
1004 dReal getAngle2Rate() const
1005 { return dJointGetPUAngle2Rate (get_id()); }
1007 dReal getPosition() const
1008 { return dJointGetPUPosition (get_id()); }
1009 dReal getPositionRate() const
1010 { return dJointGetPUPositionRate (get_id()); }
1012 virtual void setParam (int parameter, dReal value)
1013 { dJointSetPUParam (get_id(), parameter, value); }
1014 virtual dReal getParam (int parameter) const
1015 { return dJointGetPUParam (get_id(), parameter); }
1016 // TODO: expose params through methods
1023 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1024 class dPistonJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
1027 // intentionally undefined, don't use these
1028 dPistonJointTemplate (const dPistonJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1029 void operator = (const dPistonJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1032 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1034 dJointID get_id() const { return dBaseTemplate::get_id(); }
1035 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1037 void destroy() { dBaseTemplate::destroy(); }
1040 dPistonJointTemplate() { }
1041 dPistonJointTemplate (dWorldID world, dJointGroupID group=0)
1042 { set_id(dJointCreatePiston(world, group)); }
1043 dPistonJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1044 { set_id(dJointCreatePiston(world, group)); }
1046 void create (dWorldID world, dJointGroupID group=0)
1049 set_id(dJointCreatePiston(world, group));
1051 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1052 { create(world.id(), group); }
1054 void setAnchor (dReal x, dReal y, dReal z)
1055 { dJointSetPistonAnchor (get_id(), x, y, z); }
1056 void setAnchor (const dVector3 a)
1057 { setAnchor (a[0], a[1], a[2]); }
1058 void getAnchor (dVector3 result) const
1059 { dJointGetPistonAnchor (get_id(), result); }
1060 void getAnchor2 (dVector3 result) const
1061 { dJointGetPistonAnchor2 (get_id(), result); }
1063 void setAxis (dReal x, dReal y, dReal z)
1064 { dJointSetPistonAxis (get_id(), x, y, z); }
1065 void setAxis (const dVector3 a)
1066 { setAxis(a[0], a[1], a[2]); }
1067 void getAxis (dVector3 result) const
1068 { dJointGetPistonAxis (get_id(), result); }
1070 dReal getPosition() const
1071 { return dJointGetPistonPosition (get_id()); }
1072 dReal getPositionRate() const
1073 { return dJointGetPistonPositionRate (get_id()); }
1075 virtual void setParam (int parameter, dReal value)
1076 { dJointSetPistonParam (get_id(), parameter, value); }
1077 virtual dReal getParam (int parameter) const
1078 { return dJointGetPistonParam (get_id(), parameter); }
1079 // TODO: expose params through methods
1081 void addForce (dReal force)
1082 { dJointAddPistonForce (get_id(), force); }
1087 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1088 class dFixedJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
1091 // intentionally undefined, don't use these
1092 dFixedJointTemplate (const dFixedJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1093 void operator = (const dFixedJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1096 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1098 dJointID get_id() const { return dBaseTemplate::get_id(); }
1099 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1101 void destroy() { dBaseTemplate::destroy(); }
1104 dFixedJointTemplate() { }
1105 dFixedJointTemplate (dWorldID world, dJointGroupID group=0)
1106 { set_id(dJointCreateFixed(world, group)); }
1107 dFixedJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1108 { set_id(dJointCreateFixed(world, group)); }
1110 void create (dWorldID world, dJointGroupID group=0) {
1112 set_id(dJointCreateFixed(world, group));
1114 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1115 { create(world.id(), group); }
1118 { dJointSetFixed (get_id()); }
1120 virtual void setParam (int parameter, dReal value)
1121 { dJointSetFixedParam (get_id(), parameter, value); }
1123 virtual dReal getParam (int parameter) const
1124 { return dJointGetFixedParam (get_id(), parameter); }
1125 // TODO: expose params through methods
1129 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1130 class dContactJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1132 // intentionally undefined, don't use these
1133 dContactJointTemplate (const dContactJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1134 void operator = (const dContactJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1137 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1139 dJointID get_id() const { return dBaseTemplate::get_id(); }
1140 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1142 void destroy() { dBaseTemplate::destroy(); }
1145 dContactJointTemplate() { }
1146 dContactJointTemplate (dWorldID world, dJointGroupID group, dContact *contact)
1147 { set_id(dJointCreateContact(world, group, contact)); }
1148 dContactJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group, dContact *contact)
1149 { set_id(dJointCreateContact(world.id(), group, contact)); }
1151 void create (dWorldID world, dJointGroupID group, dContact *contact) {
1153 set_id(dJointCreateContact(world, group, contact));
1156 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group, dContact *contact)
1157 { create(world.id(), group, contact); }
1161 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1162 class dNullJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1164 // intentionally undefined, don't use these
1165 dNullJointTemplate (const dNullJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1166 void operator = (const dNullJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1169 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1171 dJointID get_id() const { return dBaseTemplate::get_id(); }
1172 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1174 void destroy() { dBaseTemplate::destroy(); }
1177 dNullJointTemplate() { }
1178 dNullJointTemplate (dWorldID world, dJointGroupID group=0)
1179 { set_id(dJointCreateNull(world, group)); }
1180 dNullJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1181 { set_id(dJointCreateNull (world.id(), group)); }
1183 void create (dWorldID world, dJointGroupID group=0) {
1185 set_id(dJointCreateNull(world, group));
1187 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1188 { create(world.id(), group); }
1192 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1193 class dAMotorJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1195 // intentionally undefined, don't use these
1196 dAMotorJointTemplate (const dAMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1197 void operator = (const dAMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1200 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1202 dJointID get_id() const { return dBaseTemplate::get_id(); }
1203 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1205 void destroy() { dBaseTemplate::destroy(); }
1208 dAMotorJointTemplate() { }
1209 dAMotorJointTemplate (dWorldID world, dJointGroupID group=0)
1210 { set_id(dJointCreateAMotor(world, group)); }
1211 dAMotorJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1212 { set_id(dJointCreateAMotor(world.id(), group)); }
1214 void create (dWorldID world, dJointGroupID group=0) {
1216 set_id(dJointCreateAMotor(world, group));
1218 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1219 { create(world.id(), group); }
1221 void setMode (int mode)
1222 { dJointSetAMotorMode (get_id(), mode); }
1224 { return dJointGetAMotorMode (get_id()); }
1226 void setNumAxes (int num)
1227 { dJointSetAMotorNumAxes (get_id(), num); }
1228 int getNumAxes() const
1229 { return dJointGetAMotorNumAxes (get_id()); }
1231 void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
1232 { dJointSetAMotorAxis (get_id(), anum, rel, x, y, z); }
1233 void setAxis (int anum, int rel, const dVector3 a)
1234 { setAxis(anum, rel, a[0], a[1], a[2]); }
1235 void getAxis (int anum, dVector3 result) const
1236 { dJointGetAMotorAxis (get_id(), anum, result); }
1237 int getAxisRel (int anum) const
1238 { return dJointGetAMotorAxisRel (get_id(), anum); }
1240 void setAngle (int anum, dReal angle)
1241 { dJointSetAMotorAngle (get_id(), anum, angle); }
1242 dReal getAngle (int anum) const
1243 { return dJointGetAMotorAngle (get_id(), anum); }
1244 dReal getAngleRate (int anum)
1245 { return dJointGetAMotorAngleRate (get_id(), anum); }
1247 void setParam (int parameter, dReal value)
1248 { dJointSetAMotorParam (get_id(), parameter, value); }
1249 dReal getParam (int parameter) const
1250 { return dJointGetAMotorParam (get_id(), parameter); }
1251 // TODO: expose params through methods
1253 void addTorques(dReal torque1, dReal torque2, dReal torque3)
1254 { dJointAddAMotorTorques(get_id(), torque1, torque2, torque3); }
1258 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1259 class dLMotorJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1261 // intentionally undefined, don't use these
1262 dLMotorJointTemplate (const dLMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1263 void operator = (const dLMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1266 typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1268 dJointID get_id() const { return dBaseTemplate::get_id(); }
1269 void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1271 void destroy() { dBaseTemplate::destroy(); }
1274 dLMotorJointTemplate() { }
1275 dLMotorJointTemplate (dWorldID world, dJointGroupID group=0)
1276 { set_id(dJointCreateLMotor(world, group)); }
1277 dLMotorJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1278 { set_id(dJointCreateLMotor(world.id(), group)); }
1280 void create (dWorldID world, dJointGroupID group=0) {
1282 set_id(dJointCreateLMotor(world, group));
1284 void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1285 { create(world.id(), group); }
1287 void setNumAxes (int num)
1288 { dJointSetLMotorNumAxes (get_id(), num); }
1289 int getNumAxes() const
1290 { return dJointGetLMotorNumAxes (get_id()); }
1292 void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
1293 { dJointSetLMotorAxis (get_id(), anum, rel, x, y, z); }
1294 void setAxis (int anum, int rel, const dVector3 a)
1295 { setAxis(anum, rel, a[0], a[1], a[2]); }
1296 void getAxis (int anum, dVector3 result) const
1297 { dJointGetLMotorAxis (get_id(), anum, result); }
1299 void setParam (int parameter, dReal value)
1300 { dJointSetLMotorParam (get_id(), parameter, value); }
1301 dReal getParam (int parameter) const
1302 { return dJointGetLMotorParam (get_id(), parameter); }
1303 // TODO: expose params through methods
1308 #if !defined(dODECPP_WORLD_TEMPLATE_BASE)
1310 #if defined(dODECPP_BODY_TEMPLATE_BASE) || defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || defined(dODECPP_JOINT_TEMPLATE_BASE)
1311 #error All the odecpp template bases must be defined or not defined together
1314 #define dODECPP_WORLD_TEMPLATE_BASE dWorldDynamicIDContainer
1315 #define dODECPP_BODY_TEMPLATE_BASE dBodyDynamicIDContainer
1316 #define dODECPP_JOINTGROUP_TEMPLATE_BASE dJointGroupDynamicIDContainer
1317 #define dODECPP_JOINT_TEMPLATE_BASE dJointDynamicIDContainer
1319 #else // #if defined(dODECPP_WORLD_TEMPLATE_BASE)
1321 #if !defined(dODECPP_BODY_TEMPLATE_BASE) || !defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || !defined(dODECPP_JOINT_TEMPLATE_BASE)
1322 #error All the odecpp template bases must be defined or not defined together
1325 #endif // #if defined(dODECPP_WORLD_TEMPLATE_BASE)
1328 typedef dWorldTemplate<dODECPP_WORLD_TEMPLATE_BASE> dWorld;
1329 typedef dBodyTemplate<dODECPP_BODY_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE> dBody;
1330 typedef dJointGroupTemplate<dODECPP_JOINTGROUP_TEMPLATE_BASE> dJointGroup;
1331 typedef dJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dJoint;
1332 typedef dBallJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dBallJoint;
1333 typedef dHingeJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dHingeJoint;
1334 typedef dSliderJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dSliderJoint;
1335 typedef dUniversalJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dUniversalJoint;
1336 typedef dHinge2JointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dHinge2Joint;
1337 typedef dPRJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPRJoint;
1338 typedef dPUJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPUJoint;
1339 typedef dPistonJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPistonJoint;
1340 typedef dFixedJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dFixedJoint;
1341 typedef dContactJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dContactJoint;
1342 typedef dNullJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dNullJoint;
1343 typedef dAMotorJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dAMotorJoint;
1344 typedef dLMotorJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dLMotorJoint;