Open Dynamics Engine

odecpp.h

00001 /*************************************************************************
00002  *                          *
00003  * Open Dynamics Engine, Copyright (C) 2001, 2002 Russell L. Smith.   *
00004  * All rights reserved.  Email: russ@q12.org   Web: www.q12.org    *
00005  *                          *
00006  * This library is free software; you can redistribute it and/or   *
00007  * modify it under the terms of EITHER:             *
00008  *   (1) The GNU Lesser General Public License as published by the Free  *
00009  *  Software Foundation; either version 2.1 of the License, or (at  *
00010  *  your option) any later version. The text of the GNU Lesser  *
00011  *  General Public License is included with this library in the    *
00012  *  file LICENSE.TXT.                   *
00013  *   (2) The BSD-style license that is included with this library in  *
00014  *  the file LICENSE-BSD.TXT.              *
00015  *                          *
00016  * This library is distributed in the hope that it will be useful,    *
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of  *
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files    *
00019  * LICENSE.TXT and LICENSE-BSD.TXT for more details.         *
00020  *                          *
00021  *************************************************************************/
00022 
00023 /* C++ interface for non-collision stuff */
00024 
00025 
00026 #ifndef _ODE_ODECPP_H_
00027 #define _ODE_ODECPP_H_
00028 #ifdef __cplusplus
00029 
00030 
00031 
00032 
00033 //namespace ode {
00034 
00035 
00036 class dWorldSimpleIDContainer {
00037 protected:
00038    dWorldID _id;
00039 
00040    dWorldSimpleIDContainer(): _id(0) {}
00041    ~dWorldSimpleIDContainer() { destroy(); }
00042 
00043    void destroy() { 
00044       if (_id) {
00045          dWorldDestroy(_id); 
00046          _id = 0;
00047       }
00048    }
00049 };
00050 
00051 class dWorldDynamicIDContainer: public dWorldSimpleIDContainer {
00052 protected:
00053    virtual ~dWorldDynamicIDContainer() {}
00054 };
00055 
00056 template <class dWorldTemplateBase>
00057 class dWorldTemplate: public dWorldTemplateBase {
00058   // intentionally undefined, don't use these
00059   dWorldTemplate (const dWorldTemplate<dWorldTemplateBase> &);
00060   void operator= (const dWorldTemplate<dWorldTemplateBase> &);
00061 
00062 protected:
00063   dWorldID get_id() const { return dWorldTemplateBase::_id; }
00064   void set_id(dWorldID value) { dWorldTemplateBase::_id = value; }
00065 
00066 public:
00067   dWorldTemplate()
00068     { set_id(dWorldCreate()); }
00069 
00070   dWorldID id() const
00071     { return get_id(); }
00072   operator dWorldID() const
00073     { return get_id(); }
00074 
00075   void setGravity (dReal x, dReal y, dReal z)
00076     { dWorldSetGravity (get_id(), x, y, z); }
00077   void setGravity (const dVector3 g)
00078     { setGravity (g[0], g[1], g[2]); }
00079   void getGravity (dVector3 g) const
00080     { dWorldGetGravity (get_id(), g); }
00081 
00082   void setERP (dReal erp)
00083     { dWorldSetERP(get_id(), erp); }
00084   dReal getERP() const
00085     { return dWorldGetERP(get_id()); }
00086 
00087   void setCFM (dReal cfm)
00088     { dWorldSetCFM(get_id(), cfm); }
00089   dReal getCFM() const
00090     { return dWorldGetCFM(get_id()); }
00091 
00092   void step (dReal stepsize)
00093     { dWorldStep (get_id(), stepsize); }
00094 
00095   void quickStep(dReal stepsize)
00096     { dWorldQuickStep (get_id(), stepsize); }
00097   void setQuickStepNumIterations(int num)
00098     { dWorldSetQuickStepNumIterations (get_id(), num); }
00099   int getQuickStepNumIterations() const
00100     { return dWorldGetQuickStepNumIterations (get_id()); }
00101   void setQuickStepW(dReal over_relaxation)
00102     { dWorldSetQuickStepW (get_id(), over_relaxation); }
00103   dReal getQuickStepW() const
00104     { return dWorldGetQuickStepW (get_id()); }
00105 
00106   void  setAutoDisableLinearThreshold (dReal threshold) 
00107     { dWorldSetAutoDisableLinearThreshold (get_id(), threshold); }
00108   dReal getAutoDisableLinearThreshold() const
00109     { return dWorldGetAutoDisableLinearThreshold (get_id()); }
00110   void setAutoDisableAngularThreshold (dReal threshold)
00111     { dWorldSetAutoDisableAngularThreshold (get_id(), threshold); }
00112   dReal getAutoDisableAngularThreshold() const
00113     { return dWorldGetAutoDisableAngularThreshold (get_id()); }
00114   void setAutoDisableSteps (int steps)
00115     { dWorldSetAutoDisableSteps (get_id(), steps); }
00116   int getAutoDisableSteps() const
00117     { return dWorldGetAutoDisableSteps (get_id()); }
00118   void setAutoDisableTime (dReal time)
00119     { dWorldSetAutoDisableTime (get_id(), time); }
00120   dReal getAutoDisableTime() const
00121     { return dWorldGetAutoDisableTime (get_id()); }
00122   void setAutoDisableFlag (int do_auto_disable)
00123     { dWorldSetAutoDisableFlag (get_id(), do_auto_disable); }
00124   int getAutoDisableFlag() const
00125     { return dWorldGetAutoDisableFlag (get_id()); }
00126 
00127   dReal getLinearDampingThreshold() const
00128     { return dWorldGetLinearDampingThreshold(get_id()); }
00129   void setLinearDampingThreshold(dReal threshold)
00130     { dWorldSetLinearDampingThreshold(get_id(), threshold); }
00131   dReal getAngularDampingThreshold() const
00132     { return dWorldGetAngularDampingThreshold(get_id()); }
00133   void setAngularDampingThreshold(dReal threshold)
00134     { dWorldSetAngularDampingThreshold(get_id(), threshold); }
00135   dReal getLinearDamping() const
00136     { return dWorldGetLinearDamping(get_id()); }
00137   void setLinearDamping(dReal scale)
00138     { dWorldSetLinearDamping(get_id(), scale); }
00139   dReal getAngularDamping() const
00140     { return dWorldGetAngularDamping(get_id()); }
00141   void setAngularDamping(dReal scale)
00142     { dWorldSetAngularDamping(get_id(), scale); }
00143   void setDamping(dReal linear_scale, dReal angular_scale)
00144     { dWorldSetDamping(get_id(), linear_scale, angular_scale); }
00145 
00146   dReal getMaxAngularSpeed() const
00147     { return dWorldGetMaxAngularSpeed(get_id()); }
00148   void setMaxAngularSpeed(dReal max_speed)
00149     { dWorldSetMaxAngularSpeed(get_id(), max_speed); }
00150 
00151   void setContactSurfaceLayer(dReal depth)
00152     { dWorldSetContactSurfaceLayer (get_id(), depth); }
00153   dReal getContactSurfaceLayer() const
00154     { return dWorldGetContactSurfaceLayer (get_id()); }
00155 
00156   void impulseToForce (dReal stepsize, dReal ix, dReal iy, dReal iz, 
00157              dVector3 force)
00158     { dWorldImpulseToForce (get_id(), stepsize, ix, iy, iz, force); }
00159 };
00160 
00161 
00162 class dBodySimpleIDContainer {
00163 protected:
00164    dBodyID _id;
00165 
00166    dBodySimpleIDContainer(): _id(0) {}
00167    ~dBodySimpleIDContainer() { destroy(); }
00168 
00169    void destroy() { 
00170       if (_id) {
00171          dBodyDestroy(_id); 
00172          _id = 0;
00173       }
00174    }
00175 };
00176 
00177 class dBodyDynamicIDContainer: public dBodySimpleIDContainer {
00178 protected:
00179    virtual ~dBodyDynamicIDContainer() {}
00180 };
00181 
00182 template <class dBodyTemplateBase, class dWorldTemplateBase>
00183 class dBodyTemplate: public dBodyTemplateBase {
00184   // intentionally undefined, don't use these
00185   dBodyTemplate (const dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase> &);
00186   void operator= (const dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase> &);
00187 
00188 protected:
00189   dBodyID get_id() const { return dBodyTemplateBase::_id; }
00190   void set_id(dBodyID value) { dBodyTemplateBase::_id = value; }
00191 
00192   void destroy() { dBodyTemplateBase::destroy(); }
00193 
00194 public:
00195   dBodyTemplate()
00196     { }
00197   dBodyTemplate (dWorldID world)
00198     { set_id(dBodyCreate(world)); }
00199   dBodyTemplate (dWorldTemplate<dWorldTemplateBase>& world)
00200     { set_id(dBodyCreate(world.id())); }
00201 
00202   void create (dWorldID world) {
00203     destroy();
00204     set_id(dBodyCreate(world));
00205   }
00206   void create (dWorldTemplate<dWorldTemplateBase>& world) {
00207     create(world.id());
00208   }
00209 
00210   dBodyID id() const
00211     { return get_id(); }
00212   operator dBodyID() const
00213     { return get_id(); }
00214 
00215   void setData (void *data)
00216     { dBodySetData (get_id(), data); }
00217   void *getData() const
00218     { return dBodyGetData (get_id()); }
00219 
00220   void setPosition (dReal x, dReal y, dReal z)
00221     { dBodySetPosition (get_id(), x, y, z); }
00222   void setPosition (const dVector3 p)
00223     { setPosition(p[0], p[1], p[2]); }
00224 
00225   void setRotation (const dMatrix3 R)
00226     { dBodySetRotation (get_id(), R); }
00227   void setQuaternion (const dQuaternion q)
00228     { dBodySetQuaternion (get_id(), q); }
00229   void setLinearVel (dReal x, dReal y, dReal z)
00230     { dBodySetLinearVel (get_id(), x, y, z); }
00231   void setLinearVel (const dVector3 v)
00232     { setLinearVel(v[0], v[1], v[2]); }
00233   void setAngularVel (dReal x, dReal y, dReal z)
00234     { dBodySetAngularVel (get_id(), x, y, z); }
00235   void setAngularVel (const dVector3 v)
00236     { setAngularVel (v[0], v[1], v[2]); }
00237 
00238   const dReal * getPosition() const
00239     { return dBodyGetPosition (get_id()); }
00240   const dReal * getRotation() const
00241     { return dBodyGetRotation (get_id()); }
00242   const dReal * getQuaternion() const
00243     { return dBodyGetQuaternion (get_id()); }
00244   const dReal * getLinearVel() const
00245     { return dBodyGetLinearVel (get_id()); }
00246   const dReal * getAngularVel() const
00247     { return dBodyGetAngularVel (get_id()); }
00248 
00249   void setMass (const dMass *mass)
00250     { dBodySetMass (get_id(), mass); }
00251   void setMass (const dMass &mass)
00252     { setMass (&mass); }
00253   dMass getMass () const
00254     { dMass mass; dBodyGetMass (get_id(), &mass); return mass; }
00255 
00256   void addForce (dReal fx, dReal fy, dReal fz)
00257     { dBodyAddForce (get_id(), fx, fy, fz); }
00258   void addForce (const dVector3 f)
00259     { addForce (f[0], f[1], f[2]); }
00260   void addTorque (dReal fx, dReal fy, dReal fz)
00261     { dBodyAddTorque (get_id(), fx, fy, fz); }
00262   void addTorque (const dVector3 t)
00263     { addTorque(t[0], t[1], t[2]); }
00264 
00265   void addRelForce (dReal fx, dReal fy, dReal fz)
00266     { dBodyAddRelForce (get_id(), fx, fy, fz); }
00267   void addRelForce (const dVector3 f)
00268     { addRelForce (f[0], f[1], f[2]); }
00269   void addRelTorque (dReal fx, dReal fy, dReal fz)
00270     { dBodyAddRelTorque (get_id(), fx, fy, fz); }
00271   void addRelTorque (const dVector3 t)
00272     { addRelTorque (t[0], t[1], t[2]); }
00273 
00274   void addForceAtPos (dReal fx, dReal fy, dReal fz, 
00275             dReal px, dReal py, dReal pz)
00276     { dBodyAddForceAtPos (get_id(), fx, fy, fz, px, py, pz); }
00277   void addForceAtPos (const dVector3 f, const dVector3 p)
00278     { addForceAtPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
00279 
00280   void addForceAtRelPos (dReal fx, dReal fy, dReal fz, 
00281                          dReal px, dReal py, dReal pz)
00282     { dBodyAddForceAtRelPos (get_id(), fx, fy, fz, px, py, pz); }
00283   void addForceAtRelPos (const dVector3 f, const dVector3 p)
00284     { addForceAtRelPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
00285 
00286   void addRelForceAtPos (dReal fx, dReal fy, dReal fz, 
00287           dReal px, dReal py, dReal pz)
00288     { dBodyAddRelForceAtPos (get_id(), fx, fy, fz, px, py, pz); }
00289   void addRelForceAtPos (const dVector3 f, const dVector3 p)
00290     { addRelForceAtPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
00291 
00292   void addRelForceAtRelPos (dReal fx, dReal fy, dReal fz, 
00293              dReal px, dReal py, dReal pz)
00294     { dBodyAddRelForceAtRelPos (get_id(), fx, fy, fz, px, py, pz); }
00295   void addRelForceAtRelPos (const dVector3 f, const dVector3 p)
00296     { addRelForceAtRelPos (f[0], f[1], f[2], p[0], p[1], p[2]); }
00297 
00298   const dReal * getForce() const
00299     { return dBodyGetForce(get_id()); }
00300   const dReal * getTorque() const
00301     { return dBodyGetTorque(get_id()); }
00302   void setForce (dReal x, dReal y, dReal z)
00303     { dBodySetForce (get_id(), x, y, z); }
00304   void setForce (const dVector3 f)
00305     { setForce (f[0], f[1], f[2]); }
00306   void setTorque (dReal x, dReal y, dReal z)
00307     { dBodySetTorque (get_id(), x, y, z); }
00308   void setTorque (const dVector3 t)
00309   { setTorque (t[0], t[1], t[2]); }
00310 
00311   void setDynamic()
00312     { dBodySetDynamic (get_id()); }
00313   void setKinematic()
00314     { dBodySetKinematic (get_id()); }
00315   bool isKinematic() const
00316     { return dBodyIsKinematic (get_id()) != 0; }
00317 
00318   void enable()
00319     { dBodyEnable (get_id()); }
00320   void disable()
00321     { dBodyDisable (get_id()); }
00322   bool isEnabled() const
00323     { return dBodyIsEnabled (get_id()) != 0; }
00324 
00325   void getRelPointPos (dReal px, dReal py, dReal pz, dVector3 result) const
00326     { dBodyGetRelPointPos (get_id(), px, py, pz, result); }
00327   void getRelPointPos (const dVector3 p, dVector3 result) const
00328     { getRelPointPos (p[0], p[1], p[2], result); }
00329 
00330   void getRelPointVel (dReal px, dReal py, dReal pz, dVector3 result) const
00331     { dBodyGetRelPointVel (get_id(), px, py, pz, result); }
00332   void getRelPointVel (const dVector3 p, dVector3 result) const
00333     { getRelPointVel (p[0], p[1], p[2], result); }
00334 
00335   void getPointVel (dReal px, dReal py, dReal pz, dVector3 result) const
00336     { dBodyGetPointVel (get_id(), px, py, pz, result); }
00337   void getPointVel (const dVector3 p, dVector3 result) const
00338     { getPointVel (p[0], p[1], p[2], result); }
00339 
00340   void getPosRelPoint (dReal px, dReal py, dReal pz, dVector3 result) const
00341     { dBodyGetPosRelPoint (get_id(), px, py, pz, result); }
00342   void getPosRelPoint (const dVector3 p, dVector3 result) const
00343     { getPosRelPoint (p[0], p[1], p[2], result); }
00344 
00345   void vectorToWorld (dReal px, dReal py, dReal pz, dVector3 result) const
00346     { dBodyVectorToWorld (get_id(), px, py, pz, result); }
00347   void vectorToWorld (const dVector3 p, dVector3 result) const
00348     { vectorToWorld (p[0], p[1], p[2], result); }
00349 
00350   void vectorFromWorld (dReal px, dReal py, dReal pz, dVector3 result) const
00351     { dBodyVectorFromWorld (get_id(), px, py, pz, result); }
00352   void vectorFromWorld (const dVector3 p, dVector3 result) const
00353     { vectorFromWorld (p[0], p[1], p[2], result); }
00354 
00355   void setFiniteRotationMode (bool mode)
00356     { dBodySetFiniteRotationMode (get_id(), mode); }
00357 
00358   void setFiniteRotationAxis (dReal x, dReal y, dReal z)
00359     { dBodySetFiniteRotationAxis (get_id(), x, y, z); }
00360   void setFiniteRotationAxis (const dVector3 a)
00361     { setFiniteRotationAxis (a[0], a[1], a[2]); }
00362 
00363   bool getFiniteRotationMode() const
00364     { return dBodyGetFiniteRotationMode (get_id()) != 0; }
00365   void getFiniteRotationAxis (dVector3 result) const
00366     { dBodyGetFiniteRotationAxis (get_id(), result); }
00367 
00368   int getNumJoints() const
00369     { return dBodyGetNumJoints (get_id()); }
00370   dJointID getJoint (int index) const
00371     { return dBodyGetJoint (get_id(), index); }
00372 
00373   void setGravityMode (bool mode)
00374     { dBodySetGravityMode (get_id(), mode); }
00375   bool getGravityMode() const
00376     { return dBodyGetGravityMode (get_id()) != 0; }
00377 
00378   bool isConnectedTo (dBodyID body) const
00379     { return dAreConnected (get_id(), body) != 0; }
00380 
00381   void  setAutoDisableLinearThreshold (dReal threshold) 
00382     { dBodySetAutoDisableLinearThreshold (get_id(), threshold); }
00383   dReal getAutoDisableLinearThreshold() const
00384     { return dBodyGetAutoDisableLinearThreshold (get_id()); }
00385   void setAutoDisableAngularThreshold (dReal threshold)
00386     { dBodySetAutoDisableAngularThreshold (get_id(), threshold); }
00387   dReal getAutoDisableAngularThreshold() const
00388     { return dBodyGetAutoDisableAngularThreshold (get_id()); }
00389   void setAutoDisableSteps (int steps)
00390     { dBodySetAutoDisableSteps (get_id(), steps); }
00391   int getAutoDisableSteps() const
00392     { return dBodyGetAutoDisableSteps (get_id()); }
00393   void setAutoDisableTime (dReal time)
00394     { dBodySetAutoDisableTime (get_id(), time); }
00395   dReal getAutoDisableTime() const
00396     { return dBodyGetAutoDisableTime (get_id()); }
00397   void setAutoDisableFlag (bool do_auto_disable)
00398     { dBodySetAutoDisableFlag (get_id(), do_auto_disable); }
00399   bool getAutoDisableFlag() const
00400     { return dBodyGetAutoDisableFlag (get_id()) != 0; }
00401 
00402   dReal getLinearDamping() const
00403     { return dBodyGetLinearDamping(get_id()); }
00404   void setLinearDamping(dReal scale)
00405     { dBodySetLinearDamping(get_id(), scale); }
00406   dReal getAngularDamping() const
00407     { return dBodyGetAngularDamping(get_id()); }
00408   void setAngularDamping(dReal scale)
00409     { dBodySetAngularDamping(get_id(), scale); }
00410   void setDamping(dReal linear_scale, dReal angular_scale)
00411     { dBodySetDamping(get_id(), linear_scale, angular_scale); }
00412   dReal getLinearDampingThreshold() const
00413     { return dBodyGetLinearDampingThreshold(get_id()); }
00414   void setLinearDampingThreshold(dReal threshold) const
00415     { dBodySetLinearDampingThreshold(get_id(), threshold); }
00416   dReal getAngularDampingThreshold() const
00417     { return dBodyGetAngularDampingThreshold(get_id()); }
00418   void setAngularDampingThreshold(dReal threshold)
00419     { dBodySetAngularDampingThreshold(get_id(), threshold); }
00420   void setDampingDefaults()
00421     { dBodySetDampingDefaults(get_id()); }
00422 
00423   dReal getMaxAngularSpeed() const
00424     { return dBodyGetMaxAngularSpeed(get_id()); }
00425   void setMaxAngularSpeed(dReal max_speed)
00426     { dBodySetMaxAngularSpeed(get_id(), max_speed); }
00427 
00428   bool getGyroscopicMode() const
00429     { return dBodyGetGyroscopicMode(get_id()) != 0; }
00430   void setGyroscopicMode(bool mode)
00431     { dBodySetGyroscopicMode(get_id(), mode); }
00432 
00433 };
00434 
00435 
00436 class dJointGroupSimpleIDContainer {
00437 protected:
00438    dJointGroupID _id;
00439 
00440    dJointGroupSimpleIDContainer(): _id(0) {}
00441    ~dJointGroupSimpleIDContainer() { destroy(); }
00442 
00443    void destroy() { 
00444       if (_id) {
00445          dJointGroupDestroy(_id); 
00446          _id = 0;
00447       }
00448    }
00449 };
00450 
00451 class dJointGroupDynamicIDContainer: public dJointGroupSimpleIDContainer {
00452 protected:
00453    virtual ~dJointGroupDynamicIDContainer() {}
00454 };
00455 
00456 template <class dJointGroupTemplateBase>
00457 class dJointGroupTemplate: public dJointGroupTemplateBase {
00458   // intentionally undefined, don't use these
00459   dJointGroupTemplate (const dJointGroupTemplate<dJointGroupTemplateBase> &);
00460   void operator= (const dJointGroupTemplate<dJointGroupTemplateBase> &);
00461 
00462 protected:
00463   dJointGroupID get_id() const { return dJointGroupTemplateBase::_id; }
00464   void set_id(dJointGroupID value) { dJointGroupTemplateBase::_id = value; }
00465 
00466   void destroy() { dJointGroupTemplateBase::destroy(); }
00467 
00468 public:
00469   dJointGroupTemplate ()
00470     { set_id(dJointGroupCreate(0)); }
00471   
00472   void create () {
00473     destroy();
00474     set_id(dJointGroupCreate(0));
00475   }
00476 
00477   dJointGroupID id() const
00478     { return get_id(); }
00479   operator dJointGroupID() const
00480     { return get_id(); }
00481 
00482   void empty()
00483     { dJointGroupEmpty (get_id()); }
00484   void clear()
00485     { empty(); }
00486 };
00487 
00488 
00489 class dJointSimpleIDContainer {
00490 protected:
00491    dJointID _id;
00492 
00493    dJointSimpleIDContainer(): _id(0) {}
00494    ~dJointSimpleIDContainer() { destroy(); }
00495 
00496    void destroy() { 
00497       if (_id) {
00498          dJointDestroy (_id); 
00499          _id = 0;
00500       }
00501    }
00502 };
00503 
00504 class dJointDynamicIDContainer: public dJointSimpleIDContainer {
00505 protected:
00506    virtual ~dJointDynamicIDContainer() {}
00507 };
00508 
00509 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00510 class dJointTemplate: public dJointTemplateBase {
00511 private:
00512   // intentionally undefined, don't use these
00513   dJointTemplate (const dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &) ;
00514   void operator= (const dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00515 
00516 protected:
00517   dJointID get_id() const { return dJointTemplateBase::_id; }
00518   void set_id(dJointID value) { dJointTemplateBase::_id = value; }
00519 
00520   void destroy() { dJointTemplateBase::destroy(); }
00521 
00522 protected:
00523   dJointTemplate() // don't let user construct pure dJointTemplate objects
00524     { }
00525 
00526 public:
00527   dJointID id() const
00528     { return get_id(); }
00529   operator dJointID() const
00530     { return get_id(); }
00531 
00532   int getNumBodies() const
00533     { return dJointGetNumBodies(get_id()); }
00534 
00535   void attach (dBodyID body1, dBodyID body2)
00536     { dJointAttach (get_id(), body1, body2); }
00537   void attach (dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase>& body1, dBodyTemplate<dBodyTemplateBase, dWorldTemplateBase>& body2)
00538     { attach(body1.id(), body2.id()); }
00539 
00540   void enable()
00541     { dJointEnable (get_id()); }
00542   void disable()
00543     { dJointDisable (get_id()); }
00544   bool isEnabled() const
00545     { return dJointIsEnabled (get_id()) != 0; }
00546 
00547   void setData (void *data)
00548     { dJointSetData (get_id(), data); }
00549   void *getData() const
00550     { return dJointGetData (get_id()); }
00551 
00552   dJointType getType() const
00553     { return dJointGetType (get_id()); }
00554 
00555   dBodyID getBody (int index) const
00556     { return dJointGetBody (get_id(), index); }
00557 
00558   void setFeedback(dJointFeedback *fb)
00559     { dJointSetFeedback(get_id(), fb); }
00560   dJointFeedback *getFeedback() const
00561     { return dJointGetFeedback(get_id()); }
00562 
00563   // If not implemented it will do nothing as describe in the doc
00564   virtual void setParam (int, dReal) {};
00565   virtual dReal getParam (int) const { return 0; }
00566 };
00567 
00568 
00569 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00570 class dBallJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
00571 private:
00572   // intentionally undefined, don't use these
00573   dBallJointTemplate (const dBallJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00574   void operator= (const dBallJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00575 
00576 protected:
00577   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00578 
00579   dJointID get_id() const { return dBaseTemplate::get_id(); }
00580   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00581 
00582   void destroy() { dBaseTemplate::destroy(); }
00583 
00584 public:
00585   dBallJointTemplate() { }
00586   dBallJointTemplate (dWorldID world, dJointGroupID group=0)
00587     { set_id(dJointCreateBall(world, group)); }
00588   dBallJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00589     { set_id(dJointCreateBall(world.id(), group)); }
00590 
00591   void create (dWorldID world, dJointGroupID group=0) {
00592     destroy();
00593     set_id(dJointCreateBall(world, group));
00594   }
00595   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00596     { create(world.id(), group); }
00597 
00598   void setAnchor (dReal x, dReal y, dReal z)
00599     { dJointSetBallAnchor (get_id(), x, y, z); }
00600   void setAnchor (const dVector3 a)
00601     { setAnchor (a[0], a[1], a[2]); }
00602   void getAnchor (dVector3 result) const
00603     { dJointGetBallAnchor (get_id(), result); }
00604   void getAnchor2 (dVector3 result) const
00605     { dJointGetBallAnchor2 (get_id(), result); }
00606   virtual void setParam (int parameter, dReal value)
00607     { dJointSetBallParam (get_id(), parameter, value); }
00608   virtual dReal getParam (int parameter) const
00609     { return dJointGetBallParam (get_id(), parameter); }
00610   // TODO: expose params through methods
00611 } ;
00612 
00613 
00614 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00615 class dHingeJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
00616 private:
00617   // intentionally undefined, don't use these
00618   dHingeJointTemplate (const dHingeJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00619   void operator = (const dHingeJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00620 
00621 protected:
00622   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00623 
00624   dJointID get_id() const { return dBaseTemplate::get_id(); }
00625   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00626 
00627   void destroy() { dBaseTemplate::destroy(); }
00628 
00629 public:
00630   dHingeJointTemplate() { }
00631   dHingeJointTemplate (dWorldID world, dJointGroupID group=0)
00632     { set_id(dJointCreateHinge(world, group)); }
00633   dHingeJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00634     { set_id(dJointCreateHinge(world.id(), group)); }
00635 
00636   void create (dWorldID world, dJointGroupID group=0) {
00637     destroy();
00638     set_id(dJointCreateHinge (world, group));
00639   }
00640   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00641     { create(world.id(), group); }
00642   
00643   void setAnchor (dReal x, dReal y, dReal z)
00644     { dJointSetHingeAnchor (get_id(), x, y, z); }
00645   void setAnchor (const dVector3 a)
00646     { setAnchor (a[0], a[1], a[2]); }
00647   void getAnchor (dVector3 result) const
00648     { dJointGetHingeAnchor (get_id(), result); }
00649   void getAnchor2 (dVector3 result) const
00650     { dJointGetHingeAnchor2 (get_id(), result); }
00651 
00652   void setAxis (dReal x, dReal y, dReal z)
00653     { dJointSetHingeAxis (get_id(), x, y, z); }
00654   void setAxis (const dVector3 a)
00655     { setAxis(a[0], a[1], a[2]); }
00656   void getAxis (dVector3 result) const
00657     { dJointGetHingeAxis (get_id(), result); }
00658 
00659   dReal getAngle() const
00660     { return dJointGetHingeAngle (get_id()); }
00661   dReal getAngleRate() const
00662     { return dJointGetHingeAngleRate (get_id()); }
00663 
00664   virtual void setParam (int parameter, dReal value)
00665     { dJointSetHingeParam (get_id(), parameter, value); }
00666   virtual dReal getParam (int parameter) const
00667     { return dJointGetHingeParam (get_id(), parameter); }
00668   // TODO: expose params through methods
00669 
00670   void addTorque (dReal torque)
00671    { dJointAddHingeTorque(get_id(), torque); }
00672 };
00673 
00674 
00675 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00676 class dSliderJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
00677 private:
00678   // intentionally undefined, don't use these
00679   dSliderJointTemplate (const dSliderJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00680   void operator = (const dSliderJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00681 
00682 protected:
00683   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00684 
00685   dJointID get_id() const { return dBaseTemplate::get_id(); }
00686   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00687 
00688   void destroy() { dBaseTemplate::destroy(); }
00689 
00690 public:
00691   dSliderJointTemplate() { }
00692   dSliderJointTemplate (dWorldID world, dJointGroupID group=0)
00693     { set_id(dJointCreateSlider(world, group)); }
00694   dSliderJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00695     { set_id(dJointCreateSlider(world.id(), group)); }
00696 
00697   void create (dWorldID world, dJointGroupID group=0) {
00698     destroy();
00699     set_id(dJointCreateSlider(world, group));
00700   }
00701   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00702     { create(world.id(), group); }
00703 
00704   void setAxis (dReal x, dReal y, dReal z)
00705     { dJointSetSliderAxis (get_id(), x, y, z); }
00706   void setAxis (const dVector3 a)
00707     { setAxis (a[0], a[1], a[2]); }
00708   void getAxis (dVector3 result) const
00709     { dJointGetSliderAxis (get_id(), result); }
00710 
00711   dReal getPosition() const
00712     { return dJointGetSliderPosition (get_id()); }
00713   dReal getPositionRate() const
00714     { return dJointGetSliderPositionRate (get_id()); }
00715 
00716   virtual void setParam (int parameter, dReal value)
00717     { dJointSetSliderParam (get_id(), parameter, value); }
00718   virtual dReal getParam (int parameter) const
00719     { return dJointGetSliderParam (get_id(), parameter); }
00720   // TODO: expose params through methods
00721 
00722   void addForce (dReal force)
00723    { dJointAddSliderForce(get_id(), force); }
00724 };
00725 
00726 
00727 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00728 class dUniversalJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
00729 private:
00730   // intentionally undefined, don't use these
00731   dUniversalJointTemplate (const dUniversalJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00732   void operator = (const dUniversalJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00733 
00734 protected:
00735   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00736 
00737   dJointID get_id() const { return dBaseTemplate::get_id(); }
00738   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00739 
00740   void destroy() { dBaseTemplate::destroy(); }
00741 
00742 public:
00743   dUniversalJointTemplate() { }
00744   dUniversalJointTemplate (dWorldID world, dJointGroupID group=0)
00745     { set_id(dJointCreateUniversal(world, group)); }
00746   dUniversalJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00747     { set_id(dJointCreateUniversal(world.id(), group)); }
00748 
00749   void create (dWorldID world, dJointGroupID group=0) {
00750     destroy();
00751     set_id(dJointCreateUniversal(world, group));
00752   }
00753   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00754     { create(world.id(), group); }
00755 
00756   void setAnchor (dReal x, dReal y, dReal z)
00757     { dJointSetUniversalAnchor (get_id(), x, y, z); }
00758   void setAnchor (const dVector3 a)
00759     { setAnchor(a[0], a[1], a[2]); }
00760   void setAxis1 (dReal x, dReal y, dReal z)
00761     { dJointSetUniversalAxis1 (get_id(), x, y, z); }
00762   void setAxis1 (const dVector3 a)
00763     { setAxis1 (a[0], a[1], a[2]); }
00764   void setAxis2 (dReal x, dReal y, dReal z)
00765     { dJointSetUniversalAxis2 (get_id(), x, y, z); }
00766   void setAxis2 (const dVector3 a)
00767     { setAxis2 (a[0], a[1], a[2]); }
00768 
00769   void getAnchor (dVector3 result) const
00770     { dJointGetUniversalAnchor (get_id(), result); }
00771   void getAnchor2 (dVector3 result) const
00772     { dJointGetUniversalAnchor2 (get_id(), result); }
00773   void getAxis1 (dVector3 result) const
00774     { dJointGetUniversalAxis1 (get_id(), result); }
00775   void getAxis2 (dVector3 result) const
00776     { dJointGetUniversalAxis2 (get_id(), result); }
00777 
00778   virtual void setParam (int parameter, dReal value)
00779     { dJointSetUniversalParam (get_id(), parameter, value); }
00780   virtual dReal getParam (int parameter) const
00781     { return dJointGetUniversalParam (get_id(), parameter); }
00782   // TODO: expose params through methods
00783   
00784   void getAngles(dReal *angle1, dReal *angle2) const
00785     { dJointGetUniversalAngles (get_id(), angle1, angle2); }
00786 
00787   dReal getAngle1() const
00788     { return dJointGetUniversalAngle1 (get_id()); }
00789   dReal getAngle1Rate() const
00790     { return dJointGetUniversalAngle1Rate (get_id()); }
00791   dReal getAngle2() const
00792     { return dJointGetUniversalAngle2 (get_id()); }
00793   dReal getAngle2Rate() const
00794     { return dJointGetUniversalAngle2Rate (get_id()); }
00795 
00796   void addTorques (dReal torque1, dReal torque2)
00797    { dJointAddUniversalTorques(get_id(), torque1, torque2); }
00798 };
00799 
00800 
00801 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00802 class dHinge2JointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
00803 private:
00804   // intentionally undefined, don't use these
00805   dHinge2JointTemplate (const dHinge2JointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00806   void operator = (const dHinge2JointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00807 
00808 protected:
00809   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00810 
00811   dJointID get_id() const { return dBaseTemplate::get_id(); }
00812   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00813 
00814   void destroy() { dBaseTemplate::destroy(); }
00815 
00816 public:
00817   dHinge2JointTemplate() { }
00818   dHinge2JointTemplate (dWorldID world, dJointGroupID group=0)
00819     { set_id(dJointCreateHinge2(world, group)); }
00820   dHinge2JointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00821     { set_id(dJointCreateHinge2(world.id(), group)); }
00822 
00823   void create (dWorldID world, dJointGroupID group=0) {
00824     destroy();
00825     set_id(dJointCreateHinge2(world, group));
00826   }
00827   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00828     { create(world.id(), group); }
00829 
00830   void setAnchor (dReal x, dReal y, dReal z)
00831     { dJointSetHinge2Anchor (get_id(), x, y, z); }
00832   void setAnchor (const dVector3 a)
00833     { setAnchor(a[0], a[1], a[2]); }
00834   void setAxis1 (dReal x, dReal y, dReal z)
00835     { dJointSetHinge2Axis1 (get_id(), x, y, z); }
00836   void setAxis1 (const dVector3 a)
00837     { setAxis1 (a[0], a[1], a[2]); }
00838   void setAxis2 (dReal x, dReal y, dReal z)
00839     { dJointSetHinge2Axis2 (get_id(), x, y, z); }
00840   void setAxis2 (const dVector3 a)
00841     { setAxis2 (a[0], a[1], a[2]); }
00842     
00843   void getAnchor (dVector3 result) const
00844     { dJointGetHinge2Anchor (get_id(), result); }
00845   void getAnchor2 (dVector3 result) const
00846     { dJointGetHinge2Anchor2 (get_id(), result); }
00847   void getAxis1 (dVector3 result) const
00848     { dJointGetHinge2Axis1 (get_id(), result); }
00849   void getAxis2 (dVector3 result) const
00850     { dJointGetHinge2Axis2 (get_id(), result); }
00851 
00852   dReal getAngle1() const
00853     { return dJointGetHinge2Angle1 (get_id()); }
00854   dReal getAngle1Rate() const
00855     { return dJointGetHinge2Angle1Rate (get_id()); }
00856   dReal getAngle2Rate() const
00857     { return dJointGetHinge2Angle2Rate (get_id()); }
00858 
00859   virtual void setParam (int parameter, dReal value)
00860     { dJointSetHinge2Param (get_id(), parameter, value); }
00861   virtual dReal getParam (int parameter) const
00862     { return dJointGetHinge2Param (get_id(), parameter); }
00863   // TODO: expose params through methods
00864 
00865   void addTorques(dReal torque1, dReal torque2)
00866    { dJointAddHinge2Torques(get_id(), torque1, torque2); }
00867 };
00868 
00869 
00870 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00871 class dPRJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
00872 private:
00873   // intentionally undefined, don't use these
00874   dPRJointTemplate (const dPRJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00875   void operator = (const dPRJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00876 
00877 protected:
00878   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00879 
00880   dJointID get_id() const { return dBaseTemplate::get_id(); }
00881   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00882 
00883   void destroy() { dBaseTemplate::destroy(); }
00884 
00885 public:
00886   dPRJointTemplate() { }
00887   dPRJointTemplate (dWorldID world, dJointGroupID group=0)
00888     { set_id(dJointCreatePR(world, group)); }
00889   dPRJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00890     { set_id(dJointCreatePR(world.id(), group)); }
00891 
00892   void create (dWorldID world, dJointGroupID group=0) {
00893     destroy();
00894     set_id(dJointCreatePR(world, group));
00895   }
00896   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00897     { create(world.id(), group); }
00898 
00899   void setAnchor (dReal x, dReal y, dReal z)
00900     { dJointSetPRAnchor (get_id(), x, y, z); }
00901   void setAnchor (const dVector3 a)
00902     { setAnchor (a[0], a[1], a[2]); }
00903   void setAxis1 (dReal x, dReal y, dReal z)
00904     { dJointSetPRAxis1 (get_id(), x, y, z); }
00905   void setAxis1 (const dVector3 a)
00906     { setAxis1(a[0], a[1], a[2]); }
00907   void setAxis2 (dReal x, dReal y, dReal z)
00908     { dJointSetPRAxis2 (get_id(), x, y, z); }
00909   void setAxis2 (const dVector3 a)
00910     { setAxis2(a[0], a[1], a[2]); }
00911 
00912   void getAnchor (dVector3 result) const
00913     { dJointGetPRAnchor (get_id(), result); }
00914   void getAxis1 (dVector3 result) const
00915     { dJointGetPRAxis1 (get_id(), result); }
00916   void getAxis2 (dVector3 result) const
00917     { dJointGetPRAxis2 (get_id(), result); }
00918 
00919   dReal getPosition() const
00920     { return dJointGetPRPosition (get_id()); }
00921   dReal getPositionRate() const
00922     { return dJointGetPRPositionRate (get_id()); }
00923 
00924   dReal getAngle() const
00925     { return dJointGetPRAngle (get_id()); }
00926   dReal getAngleRate() const
00927     { return dJointGetPRAngleRate (get_id()); }
00928 
00929   virtual void setParam (int parameter, dReal value)
00930     { dJointSetPRParam (get_id(), parameter, value); }
00931   virtual dReal getParam (int parameter) const
00932     { return dJointGetPRParam (get_id(), parameter); }
00933 };
00934 
00935 
00936 
00937 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
00938 class dPUJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
00939 {
00940 private:
00941   // intentionally undefined, don't use these
00942   dPUJointTemplate (const dPUJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00943   void operator = (const dPUJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
00944 
00945 protected:
00946   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
00947 
00948   dJointID get_id() const { return dBaseTemplate::get_id(); }
00949   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
00950 
00951   void destroy() { dBaseTemplate::destroy(); }
00952 
00953 public:
00954   dPUJointTemplate() { }
00955   dPUJointTemplate (dWorldID world, dJointGroupID group=0)
00956     { set_id(dJointCreatePU(world, group)); }
00957   dPUJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00958     { set_id(dJointCreatePU(world.id(), group)); }
00959 
00960   void create (dWorldID world, dJointGroupID group=0)
00961   {
00962     destroy();
00963     set_id(dJointCreatePU(world, group));
00964   }
00965   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
00966   { create(world.id(), group); }
00967 
00968   void setAnchor (dReal x, dReal y, dReal z)
00969     { dJointSetPUAnchor (get_id(), x, y, z); }
00970   void setAnchor (const dVector3 a)
00971     { setAnchor (a[0], a[1], a[2]); }
00972   void setAxis1 (dReal x, dReal y, dReal z)
00973     { dJointSetPUAxis1 (get_id(), x, y, z); }
00974   void setAxis1 (const dVector3 a)
00975     { setAxis1(a[0], a[1], a[2]); }
00976   void setAxis2 (dReal x, dReal y, dReal z)
00977   { dJointSetPUAxis2 (get_id(), x, y, z); }
00978   void setAxis3 (dReal x, dReal y, dReal z)
00979   { dJointSetPUAxis3 (get_id(), x, y, z); }
00980   void setAxis3 (const dVector3 a)
00981     { setAxis3(a[0], a[1], a[2]); }
00982   void setAxisP (dReal x, dReal y, dReal z)
00983   { dJointSetPUAxis3 (get_id(), x, y, z); }
00984   void setAxisP (const dVector3 a)
00985     { setAxisP(a[0], a[1], a[2]); }
00986 
00987   virtual void getAnchor (dVector3 result) const
00988     { dJointGetPUAnchor (get_id(), result); }
00989   void getAxis1 (dVector3 result) const
00990     { dJointGetPUAxis1 (get_id(), result); }
00991   void getAxis2 (dVector3 result) const
00992     { dJointGetPUAxis2 (get_id(), result); }
00993   void getAxis3 (dVector3 result) const
00994     { dJointGetPUAxis3 (get_id(), result); }
00995   void getAxisP (dVector3 result) const
00996     { dJointGetPUAxis3 (get_id(), result); }
00997 
00998   dReal getAngle1() const
00999     { return dJointGetPUAngle1 (get_id()); }
01000   dReal getAngle1Rate() const
01001     { return dJointGetPUAngle1Rate (get_id()); }
01002   dReal getAngle2() const
01003     { return dJointGetPUAngle2 (get_id()); }
01004   dReal getAngle2Rate() const
01005     { return dJointGetPUAngle2Rate (get_id()); }
01006 
01007   dReal getPosition() const
01008     { return dJointGetPUPosition (get_id()); }
01009   dReal getPositionRate() const
01010     { return dJointGetPUPositionRate (get_id()); }
01011 
01012   virtual void setParam (int parameter, dReal value)
01013   { dJointSetPUParam (get_id(), parameter, value); }
01014   virtual dReal getParam (int parameter) const
01015     { return dJointGetPUParam (get_id(), parameter); }
01016   // TODO: expose params through methods
01017 };
01018 
01019 
01020 
01021 
01022 
01023 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
01024 class dPistonJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
01025 {
01026 private:
01027   // intentionally undefined, don't use these
01028   dPistonJointTemplate (const dPistonJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01029   void operator = (const dPistonJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01030 
01031 protected:
01032   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
01033 
01034   dJointID get_id() const { return dBaseTemplate::get_id(); }
01035   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
01036 
01037   void destroy() { dBaseTemplate::destroy(); }
01038 
01039 public:
01040   dPistonJointTemplate() { }
01041   dPistonJointTemplate (dWorldID world, dJointGroupID group=0)
01042     { set_id(dJointCreatePiston(world, group)); }
01043   dPistonJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01044     { set_id(dJointCreatePiston(world, group)); }
01045 
01046   void create (dWorldID world, dJointGroupID group=0)
01047   {
01048     destroy();
01049     set_id(dJointCreatePiston(world, group));
01050   }
01051   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01052     { create(world.id(), group); }
01053 
01054   void setAnchor (dReal x, dReal y, dReal z)
01055     { dJointSetPistonAnchor (get_id(), x, y, z); }
01056   void setAnchor (const dVector3 a)
01057     { setAnchor (a[0], a[1], a[2]); }
01058   void getAnchor (dVector3 result) const
01059     { dJointGetPistonAnchor (get_id(), result); }
01060   void getAnchor2 (dVector3 result) const
01061     { dJointGetPistonAnchor2 (get_id(), result); }
01062 
01063   void setAxis (dReal x, dReal y, dReal z)
01064     { dJointSetPistonAxis (get_id(), x, y, z); }
01065   void setAxis (const dVector3 a)
01066     { setAxis(a[0], a[1], a[2]); }
01067   void getAxis (dVector3 result) const
01068     { dJointGetPistonAxis (get_id(), result); }
01069 
01070   dReal getPosition() const
01071     { return dJointGetPistonPosition (get_id()); }
01072   dReal getPositionRate() const
01073     { return dJointGetPistonPositionRate (get_id()); }
01074 
01075   virtual void setParam (int parameter, dReal value)
01076   { dJointSetPistonParam (get_id(), parameter, value); }
01077   virtual dReal getParam (int parameter) const
01078     { return dJointGetPistonParam (get_id(), parameter); }
01079   // TODO: expose params through methods
01080 
01081   void addForce (dReal force)
01082   { dJointAddPistonForce (get_id(), force); }
01083 };
01084 
01085 
01086 
01087 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
01088 class dFixedJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase>
01089 {
01090 private:
01091   // intentionally undefined, don't use these
01092   dFixedJointTemplate (const dFixedJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01093   void operator = (const dFixedJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01094 
01095 protected:
01096   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
01097 
01098   dJointID get_id() const { return dBaseTemplate::get_id(); }
01099   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
01100 
01101   void destroy() { dBaseTemplate::destroy(); }
01102 
01103 public:
01104   dFixedJointTemplate() { }
01105   dFixedJointTemplate (dWorldID world, dJointGroupID group=0)
01106     { set_id(dJointCreateFixed(world, group)); }
01107   dFixedJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01108     { set_id(dJointCreateFixed(world, group)); }
01109 
01110   void create (dWorldID world, dJointGroupID group=0) {
01111     destroy();
01112     set_id(dJointCreateFixed(world, group));
01113   }
01114   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01115     { create(world.id(), group); }
01116 
01117   void set()
01118     { dJointSetFixed (get_id()); }
01119 
01120   virtual void setParam (int parameter, dReal value)
01121     { dJointSetFixedParam (get_id(), parameter, value); }
01122 
01123   virtual dReal getParam (int parameter) const
01124     { return dJointGetFixedParam (get_id(), parameter); }
01125   // TODO: expose params through methods
01126 };
01127 
01128 
01129 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
01130 class dContactJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
01131 private:
01132   // intentionally undefined, don't use these
01133   dContactJointTemplate (const dContactJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01134   void operator = (const dContactJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01135 
01136 protected:
01137   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
01138 
01139   dJointID get_id() const { return dBaseTemplate::get_id(); }
01140   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
01141 
01142   void destroy() { dBaseTemplate::destroy(); }
01143 
01144 public:
01145   dContactJointTemplate() { }
01146   dContactJointTemplate (dWorldID world, dJointGroupID group, dContact *contact)
01147     { set_id(dJointCreateContact(world, group, contact)); }
01148   dContactJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group, dContact *contact)
01149     { set_id(dJointCreateContact(world.id(), group, contact)); }
01150 
01151   void create (dWorldID world, dJointGroupID group, dContact *contact) {
01152     destroy();
01153     set_id(dJointCreateContact(world, group, contact));
01154   }
01155   
01156   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group, dContact *contact)
01157     { create(world.id(), group, contact); }
01158 };
01159 
01160 
01161 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
01162 class dNullJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
01163 private:
01164   // intentionally undefined, don't use these
01165   dNullJointTemplate (const dNullJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01166   void operator = (const dNullJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01167 
01168 protected:
01169   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
01170 
01171   dJointID get_id() const { return dBaseTemplate::get_id(); }
01172   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
01173 
01174   void destroy() { dBaseTemplate::destroy(); }
01175 
01176 public:
01177   dNullJointTemplate() { }
01178   dNullJointTemplate (dWorldID world, dJointGroupID group=0)
01179     { set_id(dJointCreateNull(world, group)); }
01180   dNullJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01181     { set_id(dJointCreateNull (world.id(), group)); }
01182 
01183   void create (dWorldID world, dJointGroupID group=0) {
01184     destroy();
01185     set_id(dJointCreateNull(world, group));
01186   }
01187   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01188     { create(world.id(), group); }
01189 };
01190 
01191 
01192 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
01193 class dAMotorJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
01194 private:
01195   // intentionally undefined, don't use these
01196   dAMotorJointTemplate (const dAMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01197   void operator = (const dAMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01198 
01199 protected:
01200   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
01201 
01202   dJointID get_id() const { return dBaseTemplate::get_id(); }
01203   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
01204 
01205   void destroy() { dBaseTemplate::destroy(); }
01206 
01207 public:
01208   dAMotorJointTemplate() { }
01209   dAMotorJointTemplate (dWorldID world, dJointGroupID group=0)
01210     { set_id(dJointCreateAMotor(world, group)); }
01211   dAMotorJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01212     { set_id(dJointCreateAMotor(world.id(), group)); }
01213 
01214   void create (dWorldID world, dJointGroupID group=0) {
01215     destroy();
01216     set_id(dJointCreateAMotor(world, group));
01217   }
01218   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01219     { create(world.id(), group); }
01220 
01221   void setMode (int mode)
01222     { dJointSetAMotorMode (get_id(), mode); }
01223   int getMode() const
01224     { return dJointGetAMotorMode (get_id()); }
01225 
01226   void setNumAxes (int num)
01227     { dJointSetAMotorNumAxes (get_id(), num); }
01228   int getNumAxes() const
01229     { return dJointGetAMotorNumAxes (get_id()); }
01230 
01231   void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
01232     { dJointSetAMotorAxis (get_id(), anum, rel, x, y, z); }
01233   void setAxis (int anum, int rel, const dVector3 a)
01234     { setAxis(anum, rel, a[0], a[1], a[2]); }
01235   void getAxis (int anum, dVector3 result) const
01236     { dJointGetAMotorAxis (get_id(), anum, result); }
01237   int getAxisRel (int anum) const
01238     { return dJointGetAMotorAxisRel (get_id(), anum); }
01239 
01240   void setAngle (int anum, dReal angle)
01241     { dJointSetAMotorAngle (get_id(), anum, angle); }
01242   dReal getAngle (int anum) const
01243     { return dJointGetAMotorAngle (get_id(), anum); }
01244   dReal getAngleRate (int anum)
01245     { return dJointGetAMotorAngleRate (get_id(), anum); }
01246 
01247   void setParam (int parameter, dReal value)
01248     { dJointSetAMotorParam (get_id(), parameter, value); }
01249   dReal getParam (int parameter) const
01250     { return dJointGetAMotorParam (get_id(), parameter); }
01251   // TODO: expose params through methods
01252 
01253   void addTorques(dReal torque1, dReal torque2, dReal torque3)
01254    { dJointAddAMotorTorques(get_id(), torque1, torque2, torque3); }
01255 };
01256 
01257 
01258 template <class dJointTemplateBase, class dWorldTemplateBase, class dBodyTemplateBase>
01259 class dLMotorJointTemplate : public dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> {
01260 private:
01261   // intentionally undefined, don't use these
01262   dLMotorJointTemplate (const dLMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01263   void operator = (const dLMotorJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> &);
01264 
01265 protected:
01266   typedef dJointTemplate<dJointTemplateBase, dWorldTemplateBase, dBodyTemplateBase> dBaseTemplate;
01267 
01268   dJointID get_id() const { return dBaseTemplate::get_id(); }
01269   void set_id(dJointID value) { dBaseTemplate::set_id(value); }
01270 
01271   void destroy() { dBaseTemplate::destroy(); }
01272 
01273 public:
01274   dLMotorJointTemplate() { }
01275   dLMotorJointTemplate (dWorldID world, dJointGroupID group=0)
01276     { set_id(dJointCreateLMotor(world, group)); }
01277   dLMotorJointTemplate (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01278     { set_id(dJointCreateLMotor(world.id(), group)); }
01279 
01280   void create (dWorldID world, dJointGroupID group=0) {
01281     destroy();
01282     set_id(dJointCreateLMotor(world, group));
01283   }
01284   void create (dWorldTemplate<dWorldTemplateBase>& world, dJointGroupID group=0)
01285     { create(world.id(), group); }
01286 
01287   void setNumAxes (int num)
01288     { dJointSetLMotorNumAxes (get_id(), num); }
01289   int getNumAxes() const
01290     { return dJointGetLMotorNumAxes (get_id()); }
01291 
01292   void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
01293     { dJointSetLMotorAxis (get_id(), anum, rel, x, y, z); }
01294   void setAxis (int anum, int rel, const dVector3 a)
01295     { setAxis(anum, rel, a[0], a[1], a[2]); }
01296   void getAxis (int anum, dVector3 result) const
01297     { dJointGetLMotorAxis (get_id(), anum, result); }
01298 
01299   void setParam (int parameter, dReal value)
01300     { dJointSetLMotorParam (get_id(), parameter, value); }
01301   dReal getParam (int parameter) const
01302     { return dJointGetLMotorParam (get_id(), parameter); }
01303   // TODO: expose params through methods
01304 };
01305 
01306 //}
01307 
01308 #if !defined(dODECPP_WORLD_TEMPLATE_BASE)
01309 
01310 #if defined(dODECPP_BODY_TEMPLATE_BASE) || defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || defined(dODECPP_JOINT_TEMPLATE_BASE)
01311 #error All the odecpp template bases must be defined or not defined together
01312 #endif
01313 
01314 #define dODECPP_WORLD_TEMPLATE_BASE dWorldDynamicIDContainer
01315 #define dODECPP_BODY_TEMPLATE_BASE dBodyDynamicIDContainer
01316 #define dODECPP_JOINTGROUP_TEMPLATE_BASE dJointGroupDynamicIDContainer
01317 #define dODECPP_JOINT_TEMPLATE_BASE dJointDynamicIDContainer
01318 
01319 #else // #if defined(dODECPP_WORLD_TEMPLATE_BASE)
01320 
01321 #if !defined(dODECPP_BODY_TEMPLATE_BASE) || !defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || !defined(dODECPP_JOINT_TEMPLATE_BASE)
01322 #error All the odecpp template bases must be defined or not defined together
01323 #endif
01324 
01325 #endif // #if defined(dODECPP_WORLD_TEMPLATE_BASE)
01326 
01327 
01328 typedef dWorldTemplate<dODECPP_WORLD_TEMPLATE_BASE> dWorld;
01329 typedef dBodyTemplate<dODECPP_BODY_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE> dBody;
01330 typedef dJointGroupTemplate<dODECPP_JOINTGROUP_TEMPLATE_BASE> dJointGroup;
01331 typedef dJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dJoint;
01332 typedef dBallJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dBallJoint;
01333 typedef dHingeJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dHingeJoint;
01334 typedef dSliderJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dSliderJoint;
01335 typedef dUniversalJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dUniversalJoint;
01336 typedef dHinge2JointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dHinge2Joint;
01337 typedef dPRJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPRJoint;
01338 typedef dPUJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPUJoint;
01339 typedef dPistonJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dPistonJoint;
01340 typedef dFixedJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dFixedJoint;
01341 typedef dContactJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dContactJoint;
01342 typedef dNullJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dNullJoint;
01343 typedef dAMotorJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dAMotorJoint;
01344 typedef dLMotorJointTemplate<dODECPP_JOINT_TEMPLATE_BASE, dODECPP_WORLD_TEMPLATE_BASE, dODECPP_BODY_TEMPLATE_BASE> dLMotorJoint;
01345 
01346 
01347 #endif
01348 #endif
01349 
01350 // Local variables:
01351 // mode:c++
01352 // c-basic-offset:2
01353 // End: