misc/builddeps/linux64/ode/include/ode/odecpp.h

   1 /*************************************************************************
   2  *                                                                       *
   3  * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith.       *
   4  * All rights reserved.  Email: russ@q12.org   Web: www.q12.org          *
   5  *                                                                       *
   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     *
  12  *       file LICENSE.TXT.                                               *
  13  *   (2) The BSD-style license that is included with this library in     *
  14  *       the file LICENSE-BSD.TXT.                                       *
  15  *                                                                       *
  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.                     *
  20  *                                                                       *
  21  *************************************************************************/
  22
  23 /* C++ interface for non-collision stuff */
  24
  25
  26 #ifndef _ODE_ODECPP_H_
  27 #define _ODE_ODECPP_H_
  28 #ifdef __cplusplus
  29
  30
  31
  32
  33 //namespace ode {
  34
  35
  36 class dWorldSimpleIDContainer {
  37 protected:
  38         dWorldID _id;
  39
  40         dWorldSimpleIDContainer(): _id(0) {}
  41         ~dWorldSimpleIDContainer() { destroy(); }
  42
  43         void destroy() {
  44                 if (_id) {
  45                         dWorldDestroy(_id);
  46                         _id = 0;
  47                 }
  48         }
  49 };
  50
  51 class dWorldDynamicIDContainer: public dWorldSimpleIDContainer {
  52 protected:
  53         virtual ~dWorldDynamicIDContainer() {}
  54 };
  55
  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> &);
  61
  62 protected:
  63   dWorldID get_id() const { return dWorldTemplateBase::_id; }
  64   void set_id(dWorldID value) { dWorldTemplateBase::_id = value; }
  65
  66 public:
  67   dWorldTemplate()
  68     { set_id(dWorldCreate()); }
  69
  70   dWorldID id() const
  71     { return get_id(); }
  72   operator dWorldID() const
  73     { return get_id(); }
  74
  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); }
  81
  82   void setERP (dReal erp)
  83     { dWorldSetERP(get_id(), erp); }
  84   dReal getERP() const
  85     { return dWorldGetERP(get_id()); }
  86
  87   void setCFM (dReal cfm)
  88     { dWorldSetCFM(get_id(), cfm); }
  89   dReal getCFM() const
  90     { return dWorldGetCFM(get_id()); }
  91
  92   void step (dReal stepsize)
  93     { dWorldStep (get_id(), stepsize); }
  94
  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()); }
 105
 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()); }
 126
 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); }
 145
 146   dReal getMaxAngularSpeed() const
 147     { return dWorldGetMaxAngularSpeed(get_id()); }
 148   void setMaxAngularSpeed(dReal max_speed)
 149     { dWorldSetMaxAngularSpeed(get_id(), max_speed); }
 150
 151   void setContactSurfaceLayer(dReal depth)
 152     { dWorldSetContactSurfaceLayer (get_id(), depth); }
 153   dReal getContactSurfaceLayer() const
 154     { return dWorldGetContactSurfaceLayer (get_id()); }
 155
 156   void impulseToForce (dReal stepsize, dReal ix, dReal iy, dReal iz,
 157                        dVector3 force)
 158     { dWorldImpulseToForce (get_id(), stepsize, ix, iy, iz, force); }
 159 };
 160
 161
 162 class dBodySimpleIDContainer {
 163 protected:
 164         dBodyID _id;
 165
 166         dBodySimpleIDContainer(): _id(0) {}
 167         ~dBodySimpleIDContainer() { destroy(); }
 168
 169         void destroy() {
 170                 if (_id) {
 171                         dBodyDestroy(_id);
 172                         _id = 0;
 173                 }
 174         }
 175 };
 176
 177 class dBodyDynamicIDContainer: public dBodySimpleIDContainer {
 178 protected:
 179         virtual ~dBodyDynamicIDContainer() {}
 180 };
 181
 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> &);
 187
 188 protected:
 189   dBodyID get_id() const { return dBodyTemplateBase::_id; }
 190   void set_id(dBodyID value) { dBodyTemplateBase::_id = value; }
 191
 192   void destroy() { dBodyTemplateBase::destroy(); }
 193
 194 public:
 195   dBodyTemplate()
 196     { }
 197   dBodyTemplate (dWorldID world)
 198     { set_id(dBodyCreate(world)); }
 199   dBodyTemplate (dWorldTemplate<dWorldTemplateBase>& world)
 200     { set_id(dBodyCreate(world.id())); }
 201
 202   void create (dWorldID world) {
 203     destroy();
 204     set_id(dBodyCreate(world));
 205   }
 206   void create (dWorldTemplate<dWorldTemplateBase>& world) {
 207     create(world.id());
 208   }
 209
 210   dBodyID id() const
 211     { return get_id(); }
 212   operator dBodyID() const
 213     { return get_id(); }
 214
 215   void setData (void *data)
 216     { dBodySetData (get_id(), data); }
 217   void *getData() const
 218     { return dBodyGetData (get_id()); }
 219
 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]); }
 224
 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]); }
 237
 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()); }
 248
 249   void setMass (const dMass *mass)
 250     { dBodySetMass (get_id(), mass); }
 251   void setMass (const dMass &mass)
 252     { setMass (&mass); }
 253   dMass getMass () const
 254     { dMass mass; dBodyGetMass (get_id(), &mass); return mass; }
 255
 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]); }
 264
 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]); }
 273
 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]); }
 279
 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]); }
 285
 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]); }
 291
 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]); }
 297
 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]); }
 310
 311   void setDynamic()
 312     { dBodySetDynamic (get_id()); }
 313   void setKinematic()
 314     { dBodySetKinematic (get_id()); }
 315   bool isKinematic() const
 316     { return dBodyIsKinematic (get_id()) != 0; }
 317
 318   void enable()
 319     { dBodyEnable (get_id()); }
 320   void disable()
 321     { dBodyDisable (get_id()); }
 322   bool isEnabled() const
 323     { return dBodyIsEnabled (get_id()) != 0; }
 324
 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); }
 329
 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); }
 334
 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); }
 339
 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); }
 344
 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); }
 349
 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); }
 354
 355   void setFiniteRotationMode (bool mode)
 356     { dBodySetFiniteRotationMode (get_id(), mode); }
 357
 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]); }
 362
 363   bool getFiniteRotationMode() const
 364     { return dBodyGetFiniteRotationMode (get_id()) != 0; }
 365   void getFiniteRotationAxis (dVector3 result) const
 366     { dBodyGetFiniteRotationAxis (get_id(), result); }
 367
 368   int getNumJoints() const
 369     { return dBodyGetNumJoints (get_id()); }
 370   dJointID getJoint (int index) const
 371     { return dBodyGetJoint (get_id(), index); }
 372
 373   void setGravityMode (bool mode)
 374     { dBodySetGravityMode (get_id(), mode); }
 375   bool getGravityMode() const
 376     { return dBodyGetGravityMode (get_id()) != 0; }
 377
 378   bool isConnectedTo (dBodyID body) const
 379     { return dAreConnected (get_id(), body) != 0; }
 380
 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; }
 401
 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()); }
 422
 423   dReal getMaxAngularSpeed() const
 424     { return dBodyGetMaxAngularSpeed(get_id()); }
 425   void setMaxAngularSpeed(dReal max_speed)
 426     { dBodySetMaxAngularSpeed(get_id(), max_speed); }
 427
 428   bool getGyroscopicMode() const
 429     { return dBodyGetGyroscopicMode(get_id()) != 0; }
 430   void setGyroscopicMode(bool mode)
 431     { dBodySetGyroscopicMode(get_id(), mode); }
 432
 433 };
 434
 435
 436 class dJointGroupSimpleIDContainer {
 437 protected:
 438         dJointGroupID _id;
 439
 440         dJointGroupSimpleIDContainer(): _id(0) {}
 441         ~dJointGroupSimpleIDContainer() { destroy(); }
 442
 443         void destroy() {
 444                 if (_id) {
 445                         dJointGroupDestroy(_id);
 446                         _id = 0;
 447                 }
 448         }
 449 };
 450
 451 class dJointGroupDynamicIDContainer: public dJointGroupSimpleIDContainer {
 452 protected:
 453         virtual ~dJointGroupDynamicIDContainer() {}
 454 };
 455
 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> &);
 461
 462 protected:
 463   dJointGroupID get_id() const { return dJointGroupTemplateBase::_id; }
 464   void set_id(dJointGroupID value) { dJointGroupTemplateBase::_id = value; }
 465
 466   void destroy() { dJointGroupTemplateBase::destroy(); }
 467
 468 public:
 469   dJointGroupTemplate ()
 470     { set_id(dJointGroupCreate(0)); }
 471
 472   void create () {
 473     destroy();
 474     set_id(dJointGroupCreate(0));
 475   }
 476
 477   dJointGroupID id() const
 478     { return get_id(); }
 479   operator dJointGroupID() const
 480     { return get_id(); }
 481
 482   void empty()
 483     { dJointGroupEmpty (get_id()); }
 484   void clear()
 485     { empty(); }
 486 };
 487
 488
 489 class dJointSimpleIDContainer {
 490 protected:
 491         dJointID _id;
 492
 493         dJointSimpleIDContainer(): _id(0) {}
 494         ~dJointSimpleIDContainer() { destroy(); }
 495
 496         void destroy() {
 497                 if (_id) {
 498                         dJointDestroy (_id);
 499                         _id = 0;
 500                 }
 501         }
 502 };
 503
 504 class dJointDynamicIDContainer: public dJointSimpleIDContainer {
 505 protected:
 506         virtual ~dJointDynamicIDContainer() {}
 507 };
 508
 509 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 510 class dJointTemplate: public dJointTemplateBase {
 511 private:
 512   // intentionally undefined, don't use these
 513   dJointTemplate (const dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &) ;
 514   void operator= (const dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 515
 516 protected:
 517   dJointID get_id() const { return dJointTemplateBase::_id; }
 518   void set_id(dJointID value) { dJointTemplateBase::_id = value; }
 519
 520   void destroy() { dJointTemplateBase::destroy(); }
 521
 522 protected:
 523   dJointTemplate() // don't let user construct pure dJointTemplate objects
 524     { }
 525
 526 public:
 527   dJointID id() const
 528     { return get_id(); }
 529   operator dJointID() const
 530     { return get_id(); }
 531
 532   int getNumBodies() const
 533     { return dJointGetNumBodies(get_id()); }
 534
 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()); }
 539
 540   void enable()
 541     { dJointEnable (get_id()); }
 542   void disable()
 543     { dJointDisable (get_id()); }
 544   bool isEnabled() const
 545     { return dJointIsEnabled (get_id()) != 0; }
 546
 547   void setData (void *data)
 548     { dJointSetData (get_id(), data); }
 549   void *getData() const
 550     { return dJointGetData (get_id()); }
 551
 552   dJointType getType() const
 553     { return dJointGetType (get_id()); }
 554
 555   dBodyID getBody (int index) const
 556     { return dJointGetBody (get_id(), index); }
 557
 558   void setFeedback(dJointFeedback *fb)
 559     { dJointSetFeedback(get_id(), fb); }
 560   dJointFeedback *getFeedback() const
 561     { return dJointGetFeedback(get_id()); }
 562
 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; }
 566 };
 567
 568
 569 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 570 class dBallJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
 571 private:
 572   // intentionally undefined, don't use these
 573   dBallJointTemplate (const dBallJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 574   void operator= (const dBallJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 575
 576 protected:
 577   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 578
 579   dJointID get_id() const { return dBaseTemplate::get_id(); }
 580   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 581
 582   void destroy() { dBaseTemplate::destroy(); }
 583
 584 public:
 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)); }
 590
 591   void create (dWorldID world, dJointGroupID group=0) {
 592     destroy();
 593     set_id(dJointCreateBall(world, group));
 594   }
 595   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 596     { create(world.id(), group); }
 597
 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
 611 } ;
 612
 613
 614 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 615 class dHingeJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
 616 private:
 617   // intentionally undefined, don't use these
 618   dHingeJointTemplate (const dHingeJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 619   void operator = (const dHingeJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 620
 621 protected:
 622   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 623
 624   dJointID get_id() const { return dBaseTemplate::get_id(); }
 625   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 626
 627   void destroy() { dBaseTemplate::destroy(); }
 628
 629 public:
 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)); }
 635
 636   void create (dWorldID world, dJointGroupID group=0) {
 637     destroy();
 638     set_id(dJointCreateHinge (world, group));
 639   }
 640   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 641     { create(world.id(), group); }
 642
 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); }
 651
 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); }
 658
 659   dReal getAngle() const
 660     { return dJointGetHingeAngle (get_id()); }
 661   dReal getAngleRate() const
 662     { return dJointGetHingeAngleRate (get_id()); }
 663
 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
 669
 670   void addTorque (dReal torque)
 671         { dJointAddHingeTorque(get_id(), torque); }
 672 };
 673
 674
 675 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 676 class dSliderJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
 677 private:
 678   // intentionally undefined, don't use these
 679   dSliderJointTemplate (const dSliderJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 680   void operator = (const dSliderJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 681
 682 protected:
 683   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 684
 685   dJointID get_id() const { return dBaseTemplate::get_id(); }
 686   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 687
 688   void destroy() { dBaseTemplate::destroy(); }
 689
 690 public:
 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)); }
 696
 697   void create (dWorldID world, dJointGroupID group=0) {
 698     destroy();
 699     set_id(dJointCreateSlider(world, group));
 700   }
 701   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 702     { create(world.id(), group); }
 703
 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); }
 710
 711   dReal getPosition() const
 712     { return dJointGetSliderPosition (get_id()); }
 713   dReal getPositionRate() const
 714     { return dJointGetSliderPositionRate (get_id()); }
 715
 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
 721
 722   void addForce (dReal force)
 723         { dJointAddSliderForce(get_id(), force); }
 724 };
 725
 726
 727 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 728 class dUniversalJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
 729 private:
 730   // intentionally undefined, don't use these
 731   dUniversalJointTemplate (const dUniversalJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 732   void operator = (const dUniversalJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 733
 734 protected:
 735   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 736
 737   dJointID get_id() const { return dBaseTemplate::get_id(); }
 738   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 739
 740   void destroy() { dBaseTemplate::destroy(); }
 741
 742 public:
 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)); }
 748
 749   void create (dWorldID world, dJointGroupID group=0) {
 750     destroy();
 751     set_id(dJointCreateUniversal(world, group));
 752   }
 753   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 754     { create(world.id(), group); }
 755
 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]); }
 768
 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); }
 777
 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
 783
 784   void getAngles(dReal *angle1, dReal *angle2) const
 785     { dJointGetUniversalAngles (get_id(), angle1, angle2); }
 786
 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()); }
 795
 796   void addTorques (dReal torque1, dReal torque2)
 797         { dJointAddUniversalTorques(get_id(), torque1, torque2); }
 798 };
 799
 800
 801 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 802 class dHinge2JointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
 803 private:
 804   // intentionally undefined, don't use these
 805   dHinge2JointTemplate (const dHinge2JointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 806   void operator = (const dHinge2JointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 807
 808 protected:
 809   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 810
 811   dJointID get_id() const { return dBaseTemplate::get_id(); }
 812   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 813
 814   void destroy() { dBaseTemplate::destroy(); }
 815
 816 public:
 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)); }
 822
 823   void create (dWorldID world, dJointGroupID group=0) {
 824     destroy();
 825     set_id(dJointCreateHinge2(world, group));
 826   }
 827   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 828     { create(world.id(), group); }
 829
 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 setAxes (const dReal *axis1/*=NULL*/, const dReal *axis2/*=NULL*/)
 835     {  dJointSetHinge2Axes (get_id(), axis1, axis2); }
 836   ODE_API_DEPRECATED void setAxis1 (dReal x, dReal y, dReal z)
 837     { dVector3 a = { x, y, z }; dJointSetHinge2Axes (get_id(), a, NULL); }
 838   ODE_API_DEPRECATED void setAxis1 (const dVector3 a)
 839     { dJointSetHinge2Axes (get_id(), a, NULL); }
 840   ODE_API_DEPRECATED void setAxis2 (dReal x, dReal y, dReal z)
 841     { dVector3 a = { x, y, z }; dJointSetHinge2Axes (get_id(), NULL, a); }
 842   ODE_API_DEPRECATED void setAxis2 (const dVector3 a)
 843     { dJointSetHinge2Axes (get_id(), NULL, a); }
 844
 845   void getAnchor (dVector3 result) const
 846     { dJointGetHinge2Anchor (get_id(), result); }
 847   void getAnchor2 (dVector3 result) const
 848     { dJointGetHinge2Anchor2 (get_id(), result); }
 849   void getAxis1 (dVector3 result) const
 850     { dJointGetHinge2Axis1 (get_id(), result); }
 851   void getAxis2 (dVector3 result) const
 852     { dJointGetHinge2Axis2 (get_id(), result); }
 853
 854   dReal getAngle1() const
 855     { return dJointGetHinge2Angle1 (get_id()); }
 856   dReal getAngle1Rate() const
 857     { return dJointGetHinge2Angle1Rate (get_id()); }
 858   dReal getAngle2Rate() const
 859     { return dJointGetHinge2Angle2Rate (get_id()); }
 860
 861   virtual void setParam (int parameter, dReal value)
 862     { dJointSetHinge2Param (get_id(), parameter, value); }
 863   virtual dReal getParam (int parameter) const
 864     { return dJointGetHinge2Param (get_id(), parameter); }
 865   // TODO: expose params through methods
 866
 867   void addTorques(dReal torque1, dReal torque2)
 868         { dJointAddHinge2Torques(get_id(), torque1, torque2); }
 869 };
 870
 871
 872 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 873 class dPRJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
 874 private:
 875   // intentionally undefined, don't use these
 876   dPRJointTemplate (const dPRJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 877   void operator = (const dPRJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 878
 879 protected:
 880   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 881
 882   dJointID get_id() const { return dBaseTemplate::get_id(); }
 883   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 884
 885   void destroy() { dBaseTemplate::destroy(); }
 886
 887 public:
 888   dPRJointTemplate() { }
 889   dPRJointTemplate (dWorldID world, dJointGroupID group=0)
 890     { set_id(dJointCreatePR(world, group)); }
 891   dPRJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 892     { set_id(dJointCreatePR(world.id(), group)); }
 893
 894   void create (dWorldID world, dJointGroupID group=0) {
 895     destroy();
 896     set_id(dJointCreatePR(world, group));
 897   }
 898   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 899     { create(world.id(), group); }
 900
 901   void setAnchor (dReal x, dReal y, dReal z)
 902     { dJointSetPRAnchor (get_id(), x, y, z); }
 903   void setAnchor (const dVector3 a)
 904     { setAnchor (a[0], a[1], a[2]); }
 905   void setAxis1 (dReal x, dReal y, dReal z)
 906     { dJointSetPRAxis1 (get_id(), x, y, z); }
 907   void setAxis1 (const dVector3 a)
 908     { setAxis1(a[0], a[1], a[2]); }
 909   void setAxis2 (dReal x, dReal y, dReal z)
 910     { dJointSetPRAxis2 (get_id(), x, y, z); }
 911   void setAxis2 (const dVector3 a)
 912     { setAxis2(a[0], a[1], a[2]); }
 913
 914   void getAnchor (dVector3 result) const
 915     { dJointGetPRAnchor (get_id(), result); }
 916   void getAxis1 (dVector3 result) const
 917     { dJointGetPRAxis1 (get_id(), result); }
 918   void getAxis2 (dVector3 result) const
 919     { dJointGetPRAxis2 (get_id(), result); }
 920
 921   dReal getPosition() const
 922     { return dJointGetPRPosition (get_id()); }
 923   dReal getPositionRate() const
 924     { return dJointGetPRPositionRate (get_id()); }
 925
 926   dReal getAngle() const
 927     { return dJointGetPRAngle (get_id()); }
 928   dReal getAngleRate() const
 929     { return dJointGetPRAngleRate (get_id()); }
 930
 931   virtual void setParam (int parameter, dReal value)
 932     { dJointSetPRParam (get_id(), parameter, value); }
 933   virtual dReal getParam (int parameter) const
 934     { return dJointGetPRParam (get_id(), parameter); }
 935 };
 936
 937
 938
 939 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
 940 class dPUJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
 941 {
 942 private:
 943   // intentionally undefined, don't use these
 944   dPUJointTemplate (const dPUJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 945   void operator = (const dPUJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
 946
 947 protected:
 948   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
 949
 950   dJointID get_id() const { return dBaseTemplate::get_id(); }
 951   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
 952
 953   void destroy() { dBaseTemplate::destroy(); }
 954
 955 public:
 956   dPUJointTemplate() { }
 957   dPUJointTemplate (dWorldID world, dJointGroupID group=0)
 958     { set_id(dJointCreatePU(world, group)); }
 959   dPUJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 960     { set_id(dJointCreatePU(world.id(), group)); }
 961
 962   void create (dWorldID world, dJointGroupID group=0)
 963   {
 964     destroy();
 965     set_id(dJointCreatePU(world, group));
 966   }
 967   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
 968   { create(world.id(), group); }
 969
 970   void setAnchor (dReal x, dReal y, dReal z)
 971     { dJointSetPUAnchor (get_id(), x, y, z); }
 972   void setAnchor (const dVector3 a)
 973     { setAnchor (a[0], a[1], a[2]); }
 974   void setAxis1 (dReal x, dReal y, dReal z)
 975     { dJointSetPUAxis1 (get_id(), x, y, z); }
 976   void setAxis1 (const dVector3 a)
 977     { setAxis1(a[0], a[1], a[2]); }
 978   void setAxis2 (dReal x, dReal y, dReal z)
 979   { dJointSetPUAxis2 (get_id(), x, y, z); }
 980   void setAxis3 (dReal x, dReal y, dReal z)
 981   { dJointSetPUAxis3 (get_id(), x, y, z); }
 982   void setAxis3 (const dVector3 a)
 983     { setAxis3(a[0], a[1], a[2]); }
 984   void setAxisP (dReal x, dReal y, dReal z)
 985   { dJointSetPUAxis3 (get_id(), x, y, z); }
 986   void setAxisP (const dVector3 a)
 987     { setAxisP(a[0], a[1], a[2]); }
 988
 989   virtual void getAnchor (dVector3 result) const
 990     { dJointGetPUAnchor (get_id(), result); }
 991   void getAxis1 (dVector3 result) const
 992     { dJointGetPUAxis1 (get_id(), result); }
 993   void getAxis2 (dVector3 result) const
 994     { dJointGetPUAxis2 (get_id(), result); }
 995   void getAxis3 (dVector3 result) const
 996     { dJointGetPUAxis3 (get_id(), result); }
 997   void getAxisP (dVector3 result) const
 998     { dJointGetPUAxis3 (get_id(), result); }
 999
1000   dReal getAngle1() const
1001     { return dJointGetPUAngle1 (get_id()); }
1002   dReal getAngle1Rate() const
1003     { return dJointGetPUAngle1Rate (get_id()); }
1004   dReal getAngle2() const
1005     { return dJointGetPUAngle2 (get_id()); }
1006   dReal getAngle2Rate() const
1007     { return dJointGetPUAngle2Rate (get_id()); }
1008
1009   dReal getPosition() const
1010     { return dJointGetPUPosition (get_id()); }
1011   dReal getPositionRate() const
1012     { return dJointGetPUPositionRate (get_id()); }
1013
1014   virtual void setParam (int parameter, dReal value)
1015   { dJointSetPUParam (get_id(), parameter, value); }
1016   virtual dReal getParam (int parameter) const
1017     { return dJointGetPUParam (get_id(), parameter); }
1018   // TODO: expose params through methods
1019 };
1020
1021
1022
1023
1024
1025 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1026 class dPistonJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
1027 {
1028 private:
1029   // intentionally undefined, don't use these
1030   dPistonJointTemplate (const dPistonJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1031   void operator = (const dPistonJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1032
1033 protected:
1034   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1035
1036   dJointID get_id() const { return dBaseTemplate::get_id(); }
1037   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1038
1039   void destroy() { dBaseTemplate::destroy(); }
1040
1041 public:
1042   dPistonJointTemplate() { }
1043   dPistonJointTemplate (dWorldID world, dJointGroupID group=0)
1044     { set_id(dJointCreatePiston(world, group)); }
1045   dPistonJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1046     { set_id(dJointCreatePiston(world, group)); }
1047
1048   void create (dWorldID world, dJointGroupID group=0)
1049   {
1050     destroy();
1051     set_id(dJointCreatePiston(world, group));
1052   }
1053   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1054     { create(world.id(), group); }
1055
1056   void setAnchor (dReal x, dReal y, dReal z)
1057     { dJointSetPistonAnchor (get_id(), x, y, z); }
1058   void setAnchor (const dVector3 a)
1059     { setAnchor (a[0], a[1], a[2]); }
1060   void getAnchor (dVector3 result) const
1061     { dJointGetPistonAnchor (get_id(), result); }
1062   void getAnchor2 (dVector3 result) const
1063     { dJointGetPistonAnchor2 (get_id(), result); }
1064
1065   void setAxis (dReal x, dReal y, dReal z)
1066     { dJointSetPistonAxis (get_id(), x, y, z); }
1067   void setAxis (const dVector3 a)
1068     { setAxis(a[0], a[1], a[2]); }
1069   void getAxis (dVector3 result) const
1070     { dJointGetPistonAxis (get_id(), result); }
1071
1072   dReal getPosition() const
1073     { return dJointGetPistonPosition (get_id()); }
1074   dReal getPositionRate() const
1075     { return dJointGetPistonPositionRate (get_id()); }
1076
1077   virtual void setParam (int parameter, dReal value)
1078   { dJointSetPistonParam (get_id(), parameter, value); }
1079   virtual dReal getParam (int parameter) const
1080     { return dJointGetPistonParam (get_id(), parameter); }
1081   // TODO: expose params through methods
1082
1083   void addForce (dReal force)
1084   { dJointAddPistonForce (get_id(), force); }
1085 };
1086
1087
1088
1089 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1090 class dFixedJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
1091 {
1092 private:
1093   // intentionally undefined, don't use these
1094   dFixedJointTemplate (const dFixedJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1095   void operator = (const dFixedJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1096
1097 protected:
1098   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1099
1100   dJointID get_id() const { return dBaseTemplate::get_id(); }
1101   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1102
1103   void destroy() { dBaseTemplate::destroy(); }
1104
1105 public:
1106   dFixedJointTemplate() { }
1107   dFixedJointTemplate (dWorldID world, dJointGroupID group=0)
1108     { set_id(dJointCreateFixed(world, group)); }
1109   dFixedJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1110     { set_id(dJointCreateFixed(world, group)); }
1111
1112   void create (dWorldID world, dJointGroupID group=0) {
1113     destroy();
1114     set_id(dJointCreateFixed(world, group));
1115   }
1116   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1117     { create(world.id(), group); }
1118
1119   void set()
1120     { dJointSetFixed (get_id()); }
1121
1122   virtual void setParam (int parameter, dReal value)
1123     { dJointSetFixedParam (get_id(), parameter, value); }
1124
1125   virtual dReal getParam (int parameter) const
1126     { return dJointGetFixedParam (get_id(), parameter); }
1127   // TODO: expose params through methods
1128 };
1129
1130
1131 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1132 class dContactJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1133 private:
1134   // intentionally undefined, don't use these
1135   dContactJointTemplate (const dContactJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1136   void operator = (const dContactJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1137
1138 protected:
1139   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1140
1141   dJointID get_id() const { return dBaseTemplate::get_id(); }
1142   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1143
1144   void destroy() { dBaseTemplate::destroy(); }
1145
1146 public:
1147   dContactJointTemplate() { }
1148   dContactJointTemplate (dWorldID world, dJointGroupID group, dContact *contact)
1149     { set_id(dJointCreateContact(world, group, contact)); }
1150   dContactJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group, dContact *contact)
1151     { set_id(dJointCreateContact(world.id(), group, contact)); }
1152
1153   void create (dWorldID world, dJointGroupID group, dContact *contact) {
1154     destroy();
1155     set_id(dJointCreateContact(world, group, contact));
1156   }
1157
1158   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group, dContact *contact)
1159     { create(world.id(), group, contact); }
1160 };
1161
1162
1163 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1164 class dNullJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1165 private:
1166   // intentionally undefined, don't use these
1167   dNullJointTemplate (const dNullJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1168   void operator = (const dNullJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1169
1170 protected:
1171   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1172
1173   dJointID get_id() const { return dBaseTemplate::get_id(); }
1174   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1175
1176   void destroy() { dBaseTemplate::destroy(); }
1177
1178 public:
1179   dNullJointTemplate() { }
1180   dNullJointTemplate (dWorldID world, dJointGroupID group=0)
1181     { set_id(dJointCreateNull(world, group)); }
1182   dNullJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1183     { set_id(dJointCreateNull (world.id(), group)); }
1184
1185   void create (dWorldID world, dJointGroupID group=0) {
1186     destroy();
1187     set_id(dJointCreateNull(world, group));
1188   }
1189   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1190     { create(world.id(), group); }
1191 };
1192
1193
1194 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1195 class dAMotorJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1196 private:
1197   // intentionally undefined, don't use these
1198   dAMotorJointTemplate (const dAMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1199   void operator = (const dAMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1200
1201 protected:
1202   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1203
1204   dJointID get_id() const { return dBaseTemplate::get_id(); }
1205   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1206
1207   void destroy() { dBaseTemplate::destroy(); }
1208
1209 public:
1210   dAMotorJointTemplate() { }
1211   dAMotorJointTemplate (dWorldID world, dJointGroupID group=0)
1212     { set_id(dJointCreateAMotor(world, group)); }
1213   dAMotorJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1214     { set_id(dJointCreateAMotor(world.id(), group)); }
1215
1216   void create (dWorldID world, dJointGroupID group=0) {
1217     destroy();
1218     set_id(dJointCreateAMotor(world, group));
1219   }
1220   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1221     { create(world.id(), group); }
1222
1223   void setMode (int mode)
1224     { dJointSetAMotorMode (get_id(), mode); }
1225   int getMode() const
1226     { return dJointGetAMotorMode (get_id()); }
1227
1228   void setNumAxes (int num)
1229     { dJointSetAMotorNumAxes (get_id(), num); }
1230   int getNumAxes() const
1231     { return dJointGetAMotorNumAxes (get_id()); }
1232
1233   void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
1234     { dJointSetAMotorAxis (get_id(), anum, rel, x, y, z); }
1235   void setAxis (int anum, int rel, const dVector3 a)
1236     { setAxis(anum, rel, a[0], a[1], a[2]); }
1237   void getAxis (int anum, dVector3 result) const
1238     { dJointGetAMotorAxis (get_id(), anum, result); }
1239   int getAxisRel (int anum) const
1240     { return dJointGetAMotorAxisRel (get_id(), anum); }
1241
1242   void setAngle (int anum, dReal angle)
1243     { dJointSetAMotorAngle (get_id(), anum, angle); }
1244   dReal getAngle (int anum) const
1245     { return dJointGetAMotorAngle (get_id(), anum); }
1246   dReal getAngleRate (int anum)
1247     { return dJointGetAMotorAngleRate (get_id(), anum); }
1248
1249   void setParam (int parameter, dReal value)
1250     { dJointSetAMotorParam (get_id(), parameter, value); }
1251   dReal getParam (int parameter) const
1252     { return dJointGetAMotorParam (get_id(), parameter); }
1253   // TODO: expose params through methods
1254
1255   void addTorques(dReal torque1, dReal torque2, dReal torque3)
1256         { dJointAddAMotorTorques(get_id(), torque1, torque2, torque3); }
1257 };
1258
1259
1260 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
1261 class dLMotorJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
1262 private:
1263   // intentionally undefined, don't use these
1264   dLMotorJointTemplate (const dLMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1265   void operator = (const dLMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
1266
1267 protected:
1268   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
1269
1270   dJointID get_id() const { return dBaseTemplate::get_id(); }
1271   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
1272
1273   void destroy() { dBaseTemplate::destroy(); }
1274
1275 public:
1276   dLMotorJointTemplate() { }
1277   dLMotorJointTemplate (dWorldID world, dJointGroupID group=0)
1278     { set_id(dJointCreateLMotor(world, group)); }
1279   dLMotorJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1280     { set_id(dJointCreateLMotor(world.id(), group)); }
1281
1282   void create (dWorldID world, dJointGroupID group=0) {
1283     destroy();
1284     set_id(dJointCreateLMotor(world, group));
1285   }
1286   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
1287     { create(world.id(), group); }
1288
1289   void setNumAxes (int num)
1290     { dJointSetLMotorNumAxes (get_id(), num); }
1291   int getNumAxes() const
1292     { return dJointGetLMotorNumAxes (get_id()); }
1293
1294   void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
1295     { dJointSetLMotorAxis (get_id(), anum, rel, x, y, z); }
1296   void setAxis (int anum, int rel, const dVector3 a)
1297     { setAxis(anum, rel, a[0], a[1], a[2]); }
1298   void getAxis (int anum, dVector3 result) const
1299     { dJointGetLMotorAxis (get_id(), anum, result); }
1300
1301   void setParam (int parameter, dReal value)
1302     { dJointSetLMotorParam (get_id(), parameter, value); }
1303   dReal getParam (int parameter) const
1304     { return dJointGetLMotorParam (get_id(), parameter); }
1305   // TODO: expose params through methods
1306 };
1307
1308 //}
1309
1310 #if !defined(dODECPP_WORLD_TEMPLATE_BASE)
1311
1312 #if defined(dODECPP_BODY_TEMPLATE_BASE) || defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || defined(dODECPP_JOINT_TEMPLATE_BASE)
1313 #error All the odecpp template bases must be defined or not defined together
1314 #endif
1315
1316 #define dODECPP_WORLD_TEMPLATE_BASE dWorldDynamicIDContainer
1317 #define dODECPP_BODY_TEMPLATE_BASE dBodyDynamicIDContainer
1318 #define dODECPP_JOINTGROUP_TEMPLATE_BASE dJointGroupDynamicIDContainer
1319 #define dODECPP_JOINT_TEMPLATE_BASE dJointDynamicIDContainer
1320
1321 #else // #if defined(dODECPP_WORLD_TEMPLATE_BASE)
1322
1323 #if !defined(dODECPP_BODY_TEMPLATE_BASE) || !defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || !defined(dODECPP_JOINT_TEMPLATE_BASE)
1324 #error All the odecpp template bases must be defined or not defined together
1325 #endif
1326
1327 #endif // #if defined(dODECPP_WORLD_TEMPLATE_BASE)
1328
1329
1330 typedef dWorldTemplate<dODECPP_WORLD_TEMPLATE_BASE> dWorld;
1331 typedef dBodyTemplate<dODECPP_BODY_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE> dBody;
1332 typedef dJointGroupTemplate<dODECPP_JOINTGROUP_TEMPLATE_BASE> dJointGroup;
1333 typedef dJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dJoint;
1334 typedef dBallJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dBallJoint;
1335 typedef dHingeJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dHingeJoint;
1336 typedef dSliderJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dSliderJoint;
1337 typedef dUniversalJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dUniversalJoint;
1338 typedef dHinge2JointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dHinge2Joint;
1339 typedef dPRJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPRJoint;
1340 typedef dPUJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPUJoint;
1341 typedef dPistonJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPistonJoint;
1342 typedef dFixedJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dFixedJoint;
1343 typedef dContactJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dContactJoint;
1344 typedef dNullJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dNullJoint;
1345 typedef dAMotorJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dAMotorJoint;
1346 typedef dLMotorJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dLMotorJoint;
1347
1348
1349 #endif
1350 #endif
1351
1352 // Local variables:
1353 // mode:c++
1354 // c-basic-offset:2
1355 // End: