Open Dynamics Engine
|
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: