/************************************************************************* * * * Open Dynamics Engine, Copyright (C) 2001, 2002 Russell L. Smith. * * All rights reserved. Email: russ@q12.org Web: www.q12.org * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of EITHER: * * (1) The GNU Lesser General Public License as published by the Free * * Software Foundation; either version 2.1 of the License, or (at * * your option) any later version. The text of the GNU Lesser * * General Public License is included with this library in the * * file LICENSE.TXT. * * (2) The BSD-style license that is included with this library in * * the file LICENSE-BSD.TXT. * * * * This library is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files * * LICENSE.TXT and LICENSE-BSD.TXT for more details. * * * *************************************************************************/ /* C++ interface for non-collision stuff */ #ifndef _ODE_ODECPP_H_ #define _ODE_ODECPP_H_ #ifdef __cplusplus //namespace ode { class dWorldSimpleIDContainer { protected: dWorldID _id; dWorldSimpleIDContainer(): _id(0) {} ~dWorldSimpleIDContainer() { destroy(); } void destroy() { if (_id) { dWorldDestroy(_id); _id = 0; } } }; class dWorldDynamicIDContainer: public dWorldSimpleIDContainer { protected: virtual ~dWorldDynamicIDContainer() {} }; template class dWorldTemplate: public dWorldTemplateBase { // intentionally undefined, don't use these dWorldTemplate (const dWorldTemplate &); void operator= (const dWorldTemplate &); protected: dWorldID get_id() const { return dWorldTemplateBase::_id; } void set_id(dWorldID value) { dWorldTemplateBase::_id = value; } public: dWorldTemplate() { set_id(dWorldCreate()); } dWorldID id() const { return get_id(); } operator dWorldID() const { return get_id(); } void setGravity (dReal x, dReal y, dReal z) { dWorldSetGravity (get_id(), x, y, z); } void setGravity (const dVector3 g) { setGravity (g[0], g[1], g[2]); } void getGravity (dVector3 g) const { dWorldGetGravity (get_id(), g); } void setERP (dReal erp) { dWorldSetERP(get_id(), erp); } dReal getERP() const { return dWorldGetERP(get_id()); } void setCFM (dReal cfm) { dWorldSetCFM(get_id(), cfm); } dReal getCFM() const { return dWorldGetCFM(get_id()); } void step (dReal stepsize) { dWorldStep (get_id(), stepsize); } void quickStep(dReal stepsize) { dWorldQuickStep (get_id(), stepsize); } void setQuickStepNumIterations(int num) { dWorldSetQuickStepNumIterations (get_id(), num); } int getQuickStepNumIterations() const { return dWorldGetQuickStepNumIterations (get_id()); } void setQuickStepW(dReal over_relaxation) { dWorldSetQuickStepW (get_id(), over_relaxation); } dReal getQuickStepW() const { return dWorldGetQuickStepW (get_id()); } void setAutoDisableLinearThreshold (dReal threshold) { dWorldSetAutoDisableLinearThreshold (get_id(), threshold); } dReal getAutoDisableLinearThreshold() const { return dWorldGetAutoDisableLinearThreshold (get_id()); } void setAutoDisableAngularThreshold (dReal threshold) { dWorldSetAutoDisableAngularThreshold (get_id(), threshold); } dReal getAutoDisableAngularThreshold() const { return dWorldGetAutoDisableAngularThreshold (get_id()); } void setAutoDisableSteps (int steps) { dWorldSetAutoDisableSteps (get_id(), steps); } int getAutoDisableSteps() const { return dWorldGetAutoDisableSteps (get_id()); } void setAutoDisableTime (dReal time) { dWorldSetAutoDisableTime (get_id(), time); } dReal getAutoDisableTime() const { return dWorldGetAutoDisableTime (get_id()); } void setAutoDisableFlag (int do_auto_disable) { dWorldSetAutoDisableFlag (get_id(), do_auto_disable); } int getAutoDisableFlag() const { return dWorldGetAutoDisableFlag (get_id()); } dReal getLinearDampingThreshold() const { return dWorldGetLinearDampingThreshold(get_id()); } void setLinearDampingThreshold(dReal threshold) { dWorldSetLinearDampingThreshold(get_id(), threshold); } dReal getAngularDampingThreshold() const { return dWorldGetAngularDampingThreshold(get_id()); } void setAngularDampingThreshold(dReal threshold) { dWorldSetAngularDampingThreshold(get_id(), threshold); } dReal getLinearDamping() const { return dWorldGetLinearDamping(get_id()); } void setLinearDamping(dReal scale) { dWorldSetLinearDamping(get_id(), scale); } dReal getAngularDamping() const { return dWorldGetAngularDamping(get_id()); } void setAngularDamping(dReal scale) { dWorldSetAngularDamping(get_id(), scale); } void setDamping(dReal linear_scale, dReal angular_scale) { dWorldSetDamping(get_id(), linear_scale, angular_scale); } dReal getMaxAngularSpeed() const { return dWorldGetMaxAngularSpeed(get_id()); } void setMaxAngularSpeed(dReal max_speed) { dWorldSetMaxAngularSpeed(get_id(), max_speed); } void setContactSurfaceLayer(dReal depth) { dWorldSetContactSurfaceLayer (get_id(), depth); } dReal getContactSurfaceLayer() const { return dWorldGetContactSurfaceLayer (get_id()); } void impulseToForce (dReal stepsize, dReal ix, dReal iy, dReal iz, dVector3 force) { dWorldImpulseToForce (get_id(), stepsize, ix, iy, iz, force); } }; class dBodySimpleIDContainer { protected: dBodyID _id; dBodySimpleIDContainer(): _id(0) {} ~dBodySimpleIDContainer() { destroy(); } void destroy() { if (_id) { dBodyDestroy(_id); _id = 0; } } }; class dBodyDynamicIDContainer: public dBodySimpleIDContainer { protected: virtual ~dBodyDynamicIDContainer() {} }; template class dBodyTemplate: public dBodyTemplateBase { // intentionally undefined, don't use these dBodyTemplate (const dBodyTemplate &); void operator= (const dBodyTemplate &); protected: dBodyID get_id() const { return dBodyTemplateBase::_id; } void set_id(dBodyID value) { dBodyTemplateBase::_id = value; } void destroy() { dBodyTemplateBase::destroy(); } public: dBodyTemplate() { } dBodyTemplate (dWorldID world) { set_id(dBodyCreate(world)); } dBodyTemplate (dWorldTemplate& world) { set_id(dBodyCreate(world.id())); } void create (dWorldID world) { destroy(); set_id(dBodyCreate(world)); } void create (dWorldTemplate& world) { create(world.id()); } dBodyID id() const { return get_id(); } operator dBodyID() const { return get_id(); } void setData (void *data) { dBodySetData (get_id(), data); } void *getData() const { return dBodyGetData (get_id()); } void setPosition (dReal x, dReal y, dReal z) { dBodySetPosition (get_id(), x, y, z); } void setPosition (const dVector3 p) { setPosition(p[0], p[1], p[2]); } void setRotation (const dMatrix3 R) { dBodySetRotation (get_id(), R); } void setQuaternion (const dQuaternion q) { dBodySetQuaternion (get_id(), q); } void setLinearVel (dReal x, dReal y, dReal z) { dBodySetLinearVel (get_id(), x, y, z); } void setLinearVel (const dVector3 v) { setLinearVel(v[0], v[1], v[2]); } void setAngularVel (dReal x, dReal y, dReal z) { dBodySetAngularVel (get_id(), x, y, z); } void setAngularVel (const dVector3 v) { setAngularVel (v[0], v[1], v[2]); } const dReal * getPosition() const { return dBodyGetPosition (get_id()); } const dReal * getRotation() const { return dBodyGetRotation (get_id()); } const dReal * getQuaternion() const { return dBodyGetQuaternion (get_id()); } const dReal * getLinearVel() const { return dBodyGetLinearVel (get_id()); } const dReal * getAngularVel() const { return dBodyGetAngularVel (get_id()); } void setMass (const dMass *mass) { dBodySetMass (get_id(), mass); } void setMass (const dMass &mass) { setMass (&mass); } dMass getMass () const { dMass mass; dBodyGetMass (get_id(), &mass); return mass; } void addForce (dReal fx, dReal fy, dReal fz) { dBodyAddForce (get_id(), fx, fy, fz); } void addForce (const dVector3 f) { addForce (f[0], f[1], f[2]); } void addTorque (dReal fx, dReal fy, dReal fz) { dBodyAddTorque (get_id(), fx, fy, fz); } void addTorque (const dVector3 t) { addTorque(t[0], t[1], t[2]); } void addRelForce (dReal fx, dReal fy, dReal fz) { dBodyAddRelForce (get_id(), fx, fy, fz); } void addRelForce (const dVector3 f) { addRelForce (f[0], f[1], f[2]); } void addRelTorque (dReal fx, dReal fy, dReal fz) { dBodyAddRelTorque (get_id(), fx, fy, fz); } void addRelTorque (const dVector3 t) { addRelTorque (t[0], t[1], t[2]); } void addForceAtPos (dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz) { dBodyAddForceAtPos (get_id(), fx, fy, fz, px, py, pz); } void addForceAtPos (const dVector3 f, const dVector3 p) { addForceAtPos (f[0], f[1], f[2], p[0], p[1], p[2]); } void addForceAtRelPos (dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz) { dBodyAddForceAtRelPos (get_id(), fx, fy, fz, px, py, pz); } void addForceAtRelPos (const dVector3 f, const dVector3 p) { addForceAtRelPos (f[0], f[1], f[2], p[0], p[1], p[2]); } void addRelForceAtPos (dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz) { dBodyAddRelForceAtPos (get_id(), fx, fy, fz, px, py, pz); } void addRelForceAtPos (const dVector3 f, const dVector3 p) { addRelForceAtPos (f[0], f[1], f[2], p[0], p[1], p[2]); } void addRelForceAtRelPos (dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz) { dBodyAddRelForceAtRelPos (get_id(), fx, fy, fz, px, py, pz); } void addRelForceAtRelPos (const dVector3 f, const dVector3 p) { addRelForceAtRelPos (f[0], f[1], f[2], p[0], p[1], p[2]); } const dReal * getForce() const { return dBodyGetForce(get_id()); } const dReal * getTorque() const { return dBodyGetTorque(get_id()); } void setForce (dReal x, dReal y, dReal z) { dBodySetForce (get_id(), x, y, z); } void setForce (const dVector3 f) { setForce (f[0], f[1], f[2]); } void setTorque (dReal x, dReal y, dReal z) { dBodySetTorque (get_id(), x, y, z); } void setTorque (const dVector3 t) { setTorque (t[0], t[1], t[2]); } void setDynamic() { dBodySetDynamic (get_id()); } void setKinematic() { dBodySetKinematic (get_id()); } bool isKinematic() const { return dBodyIsKinematic (get_id()) != 0; } void enable() { dBodyEnable (get_id()); } void disable() { dBodyDisable (get_id()); } bool isEnabled() const { return dBodyIsEnabled (get_id()) != 0; } void getRelPointPos (dReal px, dReal py, dReal pz, dVector3 result) const { dBodyGetRelPointPos (get_id(), px, py, pz, result); } void getRelPointPos (const dVector3 p, dVector3 result) const { getRelPointPos (p[0], p[1], p[2], result); } void getRelPointVel (dReal px, dReal py, dReal pz, dVector3 result) const { dBodyGetRelPointVel (get_id(), px, py, pz, result); } void getRelPointVel (const dVector3 p, dVector3 result) const { getRelPointVel (p[0], p[1], p[2], result); } void getPointVel (dReal px, dReal py, dReal pz, dVector3 result) const { dBodyGetPointVel (get_id(), px, py, pz, result); } void getPointVel (const dVector3 p, dVector3 result) const { getPointVel (p[0], p[1], p[2], result); } void getPosRelPoint (dReal px, dReal py, dReal pz, dVector3 result) const { dBodyGetPosRelPoint (get_id(), px, py, pz, result); } void getPosRelPoint (const dVector3 p, dVector3 result) const { getPosRelPoint (p[0], p[1], p[2], result); } void vectorToWorld (dReal px, dReal py, dReal pz, dVector3 result) const { dBodyVectorToWorld (get_id(), px, py, pz, result); } void vectorToWorld (const dVector3 p, dVector3 result) const { vectorToWorld (p[0], p[1], p[2], result); } void vectorFromWorld (dReal px, dReal py, dReal pz, dVector3 result) const { dBodyVectorFromWorld (get_id(), px, py, pz, result); } void vectorFromWorld (const dVector3 p, dVector3 result) const { vectorFromWorld (p[0], p[1], p[2], result); } void setFiniteRotationMode (bool mode) { dBodySetFiniteRotationMode (get_id(), mode); } void setFiniteRotationAxis (dReal x, dReal y, dReal z) { dBodySetFiniteRotationAxis (get_id(), x, y, z); } void setFiniteRotationAxis (const dVector3 a) { setFiniteRotationAxis (a[0], a[1], a[2]); } bool getFiniteRotationMode() const { return dBodyGetFiniteRotationMode (get_id()) != 0; } void getFiniteRotationAxis (dVector3 result) const { dBodyGetFiniteRotationAxis (get_id(), result); } int getNumJoints() const { return dBodyGetNumJoints (get_id()); } dJointID getJoint (int index) const { return dBodyGetJoint (get_id(), index); } void setGravityMode (bool mode) { dBodySetGravityMode (get_id(), mode); } bool getGravityMode() const { return dBodyGetGravityMode (get_id()) != 0; } bool isConnectedTo (dBodyID body) const { return dAreConnected (get_id(), body) != 0; } void setAutoDisableLinearThreshold (dReal threshold) { dBodySetAutoDisableLinearThreshold (get_id(), threshold); } dReal getAutoDisableLinearThreshold() const { return dBodyGetAutoDisableLinearThreshold (get_id()); } void setAutoDisableAngularThreshold (dReal threshold) { dBodySetAutoDisableAngularThreshold (get_id(), threshold); } dReal getAutoDisableAngularThreshold() const { return dBodyGetAutoDisableAngularThreshold (get_id()); } void setAutoDisableSteps (int steps) { dBodySetAutoDisableSteps (get_id(), steps); } int getAutoDisableSteps() const { return dBodyGetAutoDisableSteps (get_id()); } void setAutoDisableTime (dReal time) { dBodySetAutoDisableTime (get_id(), time); } dReal getAutoDisableTime() const { return dBodyGetAutoDisableTime (get_id()); } void setAutoDisableFlag (bool do_auto_disable) { dBodySetAutoDisableFlag (get_id(), do_auto_disable); } bool getAutoDisableFlag() const { return dBodyGetAutoDisableFlag (get_id()) != 0; } dReal getLinearDamping() const { return dBodyGetLinearDamping(get_id()); } void setLinearDamping(dReal scale) { dBodySetLinearDamping(get_id(), scale); } dReal getAngularDamping() const { return dBodyGetAngularDamping(get_id()); } void setAngularDamping(dReal scale) { dBodySetAngularDamping(get_id(), scale); } void setDamping(dReal linear_scale, dReal angular_scale) { dBodySetDamping(get_id(), linear_scale, angular_scale); } dReal getLinearDampingThreshold() const { return dBodyGetLinearDampingThreshold(get_id()); } void setLinearDampingThreshold(dReal threshold) const { dBodySetLinearDampingThreshold(get_id(), threshold); } dReal getAngularDampingThreshold() const { return dBodyGetAngularDampingThreshold(get_id()); } void setAngularDampingThreshold(dReal threshold) { dBodySetAngularDampingThreshold(get_id(), threshold); } void setDampingDefaults() { dBodySetDampingDefaults(get_id()); } dReal getMaxAngularSpeed() const { return dBodyGetMaxAngularSpeed(get_id()); } void setMaxAngularSpeed(dReal max_speed) { dBodySetMaxAngularSpeed(get_id(), max_speed); } bool getGyroscopicMode() const { return dBodyGetGyroscopicMode(get_id()) != 0; } void setGyroscopicMode(bool mode) { dBodySetGyroscopicMode(get_id(), mode); } }; class dJointGroupSimpleIDContainer { protected: dJointGroupID _id; dJointGroupSimpleIDContainer(): _id(0) {} ~dJointGroupSimpleIDContainer() { destroy(); } void destroy() { if (_id) { dJointGroupDestroy(_id); _id = 0; } } }; class dJointGroupDynamicIDContainer: public dJointGroupSimpleIDContainer { protected: virtual ~dJointGroupDynamicIDContainer() {} }; template class dJointGroupTemplate: public dJointGroupTemplateBase { // intentionally undefined, don't use these dJointGroupTemplate (const dJointGroupTemplate &); void operator= (const dJointGroupTemplate &); protected: dJointGroupID get_id() const { return dJointGroupTemplateBase::_id; } void set_id(dJointGroupID value) { dJointGroupTemplateBase::_id = value; } void destroy() { dJointGroupTemplateBase::destroy(); } public: dJointGroupTemplate () { set_id(dJointGroupCreate(0)); } void create () { destroy(); set_id(dJointGroupCreate(0)); } dJointGroupID id() const { return get_id(); } operator dJointGroupID() const { return get_id(); } void empty() { dJointGroupEmpty (get_id()); } void clear() { empty(); } }; class dJointSimpleIDContainer { protected: dJointID _id; dJointSimpleIDContainer(): _id(0) {} ~dJointSimpleIDContainer() { destroy(); } void destroy() { if (_id) { dJointDestroy (_id); _id = 0; } } }; class dJointDynamicIDContainer: public dJointSimpleIDContainer { protected: virtual ~dJointDynamicIDContainer() {} }; template class dJointTemplate: public dJointTemplateBase { private: // intentionally undefined, don't use these dJointTemplate (const dJointTemplate &) ; void operator= (const dJointTemplate &); protected: dJointID get_id() const { return dJointTemplateBase::_id; } void set_id(dJointID value) { dJointTemplateBase::_id = value; } void destroy() { dJointTemplateBase::destroy(); } protected: dJointTemplate() // don't let user construct pure dJointTemplate objects { } public: dJointID id() const { return get_id(); } operator dJointID() const { return get_id(); } int getNumBodies() const { return dJointGetNumBodies(get_id()); } void attach (dBodyID body1, dBodyID body2) { dJointAttach (get_id(), body1, body2); } void attach (dBodyTemplate& body1, dBodyTemplate& body2) { attach(body1.id(), body2.id()); } void enable() { dJointEnable (get_id()); } void disable() { dJointDisable (get_id()); } bool isEnabled() const { return dJointIsEnabled (get_id()) != 0; } void setData (void *data) { dJointSetData (get_id(), data); } void *getData() const { return dJointGetData (get_id()); } dJointType getType() const { return dJointGetType (get_id()); } dBodyID getBody (int index) const { return dJointGetBody (get_id(), index); } void setFeedback(dJointFeedback *fb) { dJointSetFeedback(get_id(), fb); } dJointFeedback *getFeedback() const { return dJointGetFeedback(get_id()); } // If not implemented it will do nothing as describe in the doc virtual void setParam (int, dReal) {}; virtual dReal getParam (int) const { return 0; } }; template class dBallJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dBallJointTemplate (const dBallJointTemplate &); void operator= (const dBallJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dBallJointTemplate() { } dBallJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateBall(world, group)); } dBallJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateBall(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateBall(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetBallAnchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor (a[0], a[1], a[2]); } void getAnchor (dVector3 result) const { dJointGetBallAnchor (get_id(), result); } void getAnchor2 (dVector3 result) const { dJointGetBallAnchor2 (get_id(), result); } virtual void setParam (int parameter, dReal value) { dJointSetBallParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetBallParam (get_id(), parameter); } // TODO: expose params through methods } ; template class dHingeJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dHingeJointTemplate (const dHingeJointTemplate &); void operator = (const dHingeJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dHingeJointTemplate() { } dHingeJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateHinge(world, group)); } dHingeJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateHinge(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateHinge (world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetHingeAnchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor (a[0], a[1], a[2]); } void getAnchor (dVector3 result) const { dJointGetHingeAnchor (get_id(), result); } void getAnchor2 (dVector3 result) const { dJointGetHingeAnchor2 (get_id(), result); } void setAxis (dReal x, dReal y, dReal z) { dJointSetHingeAxis (get_id(), x, y, z); } void setAxis (const dVector3 a) { setAxis(a[0], a[1], a[2]); } void getAxis (dVector3 result) const { dJointGetHingeAxis (get_id(), result); } dReal getAngle() const { return dJointGetHingeAngle (get_id()); } dReal getAngleRate() const { return dJointGetHingeAngleRate (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetHingeParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetHingeParam (get_id(), parameter); } // TODO: expose params through methods void addTorque (dReal torque) { dJointAddHingeTorque(get_id(), torque); } }; template class dSliderJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dSliderJointTemplate (const dSliderJointTemplate &); void operator = (const dSliderJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dSliderJointTemplate() { } dSliderJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateSlider(world, group)); } dSliderJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateSlider(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateSlider(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAxis (dReal x, dReal y, dReal z) { dJointSetSliderAxis (get_id(), x, y, z); } void setAxis (const dVector3 a) { setAxis (a[0], a[1], a[2]); } void getAxis (dVector3 result) const { dJointGetSliderAxis (get_id(), result); } dReal getPosition() const { return dJointGetSliderPosition (get_id()); } dReal getPositionRate() const { return dJointGetSliderPositionRate (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetSliderParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetSliderParam (get_id(), parameter); } // TODO: expose params through methods void addForce (dReal force) { dJointAddSliderForce(get_id(), force); } }; template class dUniversalJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dUniversalJointTemplate (const dUniversalJointTemplate &); void operator = (const dUniversalJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dUniversalJointTemplate() { } dUniversalJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateUniversal(world, group)); } dUniversalJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateUniversal(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateUniversal(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetUniversalAnchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor(a[0], a[1], a[2]); } void setAxis1 (dReal x, dReal y, dReal z) { dJointSetUniversalAxis1 (get_id(), x, y, z); } void setAxis1 (const dVector3 a) { setAxis1 (a[0], a[1], a[2]); } void setAxis2 (dReal x, dReal y, dReal z) { dJointSetUniversalAxis2 (get_id(), x, y, z); } void setAxis2 (const dVector3 a) { setAxis2 (a[0], a[1], a[2]); } void getAnchor (dVector3 result) const { dJointGetUniversalAnchor (get_id(), result); } void getAnchor2 (dVector3 result) const { dJointGetUniversalAnchor2 (get_id(), result); } void getAxis1 (dVector3 result) const { dJointGetUniversalAxis1 (get_id(), result); } void getAxis2 (dVector3 result) const { dJointGetUniversalAxis2 (get_id(), result); } virtual void setParam (int parameter, dReal value) { dJointSetUniversalParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetUniversalParam (get_id(), parameter); } // TODO: expose params through methods void getAngles(dReal *angle1, dReal *angle2) const { dJointGetUniversalAngles (get_id(), angle1, angle2); } dReal getAngle1() const { return dJointGetUniversalAngle1 (get_id()); } dReal getAngle1Rate() const { return dJointGetUniversalAngle1Rate (get_id()); } dReal getAngle2() const { return dJointGetUniversalAngle2 (get_id()); } dReal getAngle2Rate() const { return dJointGetUniversalAngle2Rate (get_id()); } void addTorques (dReal torque1, dReal torque2) { dJointAddUniversalTorques(get_id(), torque1, torque2); } }; template class dHinge2JointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dHinge2JointTemplate (const dHinge2JointTemplate &); void operator = (const dHinge2JointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dHinge2JointTemplate() { } dHinge2JointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateHinge2(world, group)); } dHinge2JointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateHinge2(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateHinge2(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetHinge2Anchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor(a[0], a[1], a[2]); } void setAxis1 (dReal x, dReal y, dReal z) { dJointSetHinge2Axis1 (get_id(), x, y, z); } void setAxis1 (const dVector3 a) { setAxis1 (a[0], a[1], a[2]); } void setAxis2 (dReal x, dReal y, dReal z) { dJointSetHinge2Axis2 (get_id(), x, y, z); } void setAxis2 (const dVector3 a) { setAxis2 (a[0], a[1], a[2]); } void getAnchor (dVector3 result) const { dJointGetHinge2Anchor (get_id(), result); } void getAnchor2 (dVector3 result) const { dJointGetHinge2Anchor2 (get_id(), result); } void getAxis1 (dVector3 result) const { dJointGetHinge2Axis1 (get_id(), result); } void getAxis2 (dVector3 result) const { dJointGetHinge2Axis2 (get_id(), result); } dReal getAngle1() const { return dJointGetHinge2Angle1 (get_id()); } dReal getAngle1Rate() const { return dJointGetHinge2Angle1Rate (get_id()); } dReal getAngle2Rate() const { return dJointGetHinge2Angle2Rate (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetHinge2Param (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetHinge2Param (get_id(), parameter); } // TODO: expose params through methods void addTorques(dReal torque1, dReal torque2) { dJointAddHinge2Torques(get_id(), torque1, torque2); } }; template class dPRJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dPRJointTemplate (const dPRJointTemplate &); void operator = (const dPRJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dPRJointTemplate() { } dPRJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreatePR(world, group)); } dPRJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreatePR(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreatePR(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetPRAnchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor (a[0], a[1], a[2]); } void setAxis1 (dReal x, dReal y, dReal z) { dJointSetPRAxis1 (get_id(), x, y, z); } void setAxis1 (const dVector3 a) { setAxis1(a[0], a[1], a[2]); } void setAxis2 (dReal x, dReal y, dReal z) { dJointSetPRAxis2 (get_id(), x, y, z); } void setAxis2 (const dVector3 a) { setAxis2(a[0], a[1], a[2]); } void getAnchor (dVector3 result) const { dJointGetPRAnchor (get_id(), result); } void getAxis1 (dVector3 result) const { dJointGetPRAxis1 (get_id(), result); } void getAxis2 (dVector3 result) const { dJointGetPRAxis2 (get_id(), result); } dReal getPosition() const { return dJointGetPRPosition (get_id()); } dReal getPositionRate() const { return dJointGetPRPositionRate (get_id()); } dReal getAngle() const { return dJointGetPRAngle (get_id()); } dReal getAngleRate() const { return dJointGetPRAngleRate (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetPRParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetPRParam (get_id(), parameter); } }; template class dPUJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dPUJointTemplate (const dPUJointTemplate &); void operator = (const dPUJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dPUJointTemplate() { } dPUJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreatePU(world, group)); } dPUJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreatePU(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreatePU(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetPUAnchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor (a[0], a[1], a[2]); } void setAxis1 (dReal x, dReal y, dReal z) { dJointSetPUAxis1 (get_id(), x, y, z); } void setAxis1 (const dVector3 a) { setAxis1(a[0], a[1], a[2]); } void setAxis2 (dReal x, dReal y, dReal z) { dJointSetPUAxis2 (get_id(), x, y, z); } void setAxis3 (dReal x, dReal y, dReal z) { dJointSetPUAxis3 (get_id(), x, y, z); } void setAxis3 (const dVector3 a) { setAxis3(a[0], a[1], a[2]); } void setAxisP (dReal x, dReal y, dReal z) { dJointSetPUAxis3 (get_id(), x, y, z); } void setAxisP (const dVector3 a) { setAxisP(a[0], a[1], a[2]); } virtual void getAnchor (dVector3 result) const { dJointGetPUAnchor (get_id(), result); } void getAxis1 (dVector3 result) const { dJointGetPUAxis1 (get_id(), result); } void getAxis2 (dVector3 result) const { dJointGetPUAxis2 (get_id(), result); } void getAxis3 (dVector3 result) const { dJointGetPUAxis3 (get_id(), result); } void getAxisP (dVector3 result) const { dJointGetPUAxis3 (get_id(), result); } dReal getAngle1() const { return dJointGetPUAngle1 (get_id()); } dReal getAngle1Rate() const { return dJointGetPUAngle1Rate (get_id()); } dReal getAngle2() const { return dJointGetPUAngle2 (get_id()); } dReal getAngle2Rate() const { return dJointGetPUAngle2Rate (get_id()); } dReal getPosition() const { return dJointGetPUPosition (get_id()); } dReal getPositionRate() const { return dJointGetPUPositionRate (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetPUParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetPUParam (get_id(), parameter); } // TODO: expose params through methods }; template class dPistonJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dPistonJointTemplate (const dPistonJointTemplate &); void operator = (const dPistonJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dPistonJointTemplate() { } dPistonJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreatePiston(world, group)); } dPistonJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreatePiston(world, group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreatePiston(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setAnchor (dReal x, dReal y, dReal z) { dJointSetPistonAnchor (get_id(), x, y, z); } void setAnchor (const dVector3 a) { setAnchor (a[0], a[1], a[2]); } void getAnchor (dVector3 result) const { dJointGetPistonAnchor (get_id(), result); } void getAnchor2 (dVector3 result) const { dJointGetPistonAnchor2 (get_id(), result); } void setAxis (dReal x, dReal y, dReal z) { dJointSetPistonAxis (get_id(), x, y, z); } void setAxis (const dVector3 a) { setAxis(a[0], a[1], a[2]); } void getAxis (dVector3 result) const { dJointGetPistonAxis (get_id(), result); } dReal getPosition() const { return dJointGetPistonPosition (get_id()); } dReal getPositionRate() const { return dJointGetPistonPositionRate (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetPistonParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetPistonParam (get_id(), parameter); } // TODO: expose params through methods void addForce (dReal force) { dJointAddPistonForce (get_id(), force); } }; template class dFixedJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dFixedJointTemplate (const dFixedJointTemplate &); void operator = (const dFixedJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dFixedJointTemplate() { } dFixedJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateFixed(world, group)); } dFixedJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateFixed(world, group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateFixed(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void set() { dJointSetFixed (get_id()); } virtual void setParam (int parameter, dReal value) { dJointSetFixedParam (get_id(), parameter, value); } virtual dReal getParam (int parameter) const { return dJointGetFixedParam (get_id(), parameter); } // TODO: expose params through methods }; template class dContactJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dContactJointTemplate (const dContactJointTemplate &); void operator = (const dContactJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dContactJointTemplate() { } dContactJointTemplate (dWorldID world, dJointGroupID group, dContact *contact) { set_id(dJointCreateContact(world, group, contact)); } dContactJointTemplate (dWorldTemplate& world, dJointGroupID group, dContact *contact) { set_id(dJointCreateContact(world.id(), group, contact)); } void create (dWorldID world, dJointGroupID group, dContact *contact) { destroy(); set_id(dJointCreateContact(world, group, contact)); } void create (dWorldTemplate& world, dJointGroupID group, dContact *contact) { create(world.id(), group, contact); } }; template class dNullJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dNullJointTemplate (const dNullJointTemplate &); void operator = (const dNullJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dNullJointTemplate() { } dNullJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateNull(world, group)); } dNullJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateNull (world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateNull(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } }; template class dAMotorJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dAMotorJointTemplate (const dAMotorJointTemplate &); void operator = (const dAMotorJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dAMotorJointTemplate() { } dAMotorJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateAMotor(world, group)); } dAMotorJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateAMotor(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateAMotor(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setMode (int mode) { dJointSetAMotorMode (get_id(), mode); } int getMode() const { return dJointGetAMotorMode (get_id()); } void setNumAxes (int num) { dJointSetAMotorNumAxes (get_id(), num); } int getNumAxes() const { return dJointGetAMotorNumAxes (get_id()); } void setAxis (int anum, int rel, dReal x, dReal y, dReal z) { dJointSetAMotorAxis (get_id(), anum, rel, x, y, z); } void setAxis (int anum, int rel, const dVector3 a) { setAxis(anum, rel, a[0], a[1], a[2]); } void getAxis (int anum, dVector3 result) const { dJointGetAMotorAxis (get_id(), anum, result); } int getAxisRel (int anum) const { return dJointGetAMotorAxisRel (get_id(), anum); } void setAngle (int anum, dReal angle) { dJointSetAMotorAngle (get_id(), anum, angle); } dReal getAngle (int anum) const { return dJointGetAMotorAngle (get_id(), anum); } dReal getAngleRate (int anum) { return dJointGetAMotorAngleRate (get_id(), anum); } void setParam (int parameter, dReal value) { dJointSetAMotorParam (get_id(), parameter, value); } dReal getParam (int parameter) const { return dJointGetAMotorParam (get_id(), parameter); } // TODO: expose params through methods void addTorques(dReal torque1, dReal torque2, dReal torque3) { dJointAddAMotorTorques(get_id(), torque1, torque2, torque3); } }; template class dLMotorJointTemplate : public dJointTemplate { private: // intentionally undefined, don't use these dLMotorJointTemplate (const dLMotorJointTemplate &); void operator = (const dLMotorJointTemplate &); protected: typedef dJointTemplate dBaseTemplate; dJointID get_id() const { return dBaseTemplate::get_id(); } void set_id(dJointID value) { dBaseTemplate::set_id(value); } void destroy() { dBaseTemplate::destroy(); } public: dLMotorJointTemplate() { } dLMotorJointTemplate (dWorldID world, dJointGroupID group=0) { set_id(dJointCreateLMotor(world, group)); } dLMotorJointTemplate (dWorldTemplate& world, dJointGroupID group=0) { set_id(dJointCreateLMotor(world.id(), group)); } void create (dWorldID world, dJointGroupID group=0) { destroy(); set_id(dJointCreateLMotor(world, group)); } void create (dWorldTemplate& world, dJointGroupID group=0) { create(world.id(), group); } void setNumAxes (int num) { dJointSetLMotorNumAxes (get_id(), num); } int getNumAxes() const { return dJointGetLMotorNumAxes (get_id()); } void setAxis (int anum, int rel, dReal x, dReal y, dReal z) { dJointSetLMotorAxis (get_id(), anum, rel, x, y, z); } void setAxis (int anum, int rel, const dVector3 a) { setAxis(anum, rel, a[0], a[1], a[2]); } void getAxis (int anum, dVector3 result) const { dJointGetLMotorAxis (get_id(), anum, result); } void setParam (int parameter, dReal value) { dJointSetLMotorParam (get_id(), parameter, value); } dReal getParam (int parameter) const { return dJointGetLMotorParam (get_id(), parameter); } // TODO: expose params through methods }; //} #if !defined(dODECPP_WORLD_TEMPLATE_BASE) #if defined(dODECPP_BODY_TEMPLATE_BASE) || defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || defined(dODECPP_JOINT_TEMPLATE_BASE) #error All the odecpp template bases must be defined or not defined together #endif #define dODECPP_WORLD_TEMPLATE_BASE dWorldDynamicIDContainer #define dODECPP_BODY_TEMPLATE_BASE dBodyDynamicIDContainer #define dODECPP_JOINTGROUP_TEMPLATE_BASE dJointGroupDynamicIDContainer #define dODECPP_JOINT_TEMPLATE_BASE dJointDynamicIDContainer #else // #if defined(dODECPP_WORLD_TEMPLATE_BASE) #if !defined(dODECPP_BODY_TEMPLATE_BASE) || !defined(dODECPP_JOINTGROUP_TEMPLATE_BASE) || !defined(dODECPP_JOINT_TEMPLATE_BASE) #error All the odecpp template bases must be defined or not defined together #endif #endif // #if defined(dODECPP_WORLD_TEMPLATE_BASE) typedef dWorldTemplate dWorld; typedef dBodyTemplate dBody; typedef dJointGroupTemplate dJointGroup; typedef dJointTemplate dJoint; typedef dBallJointTemplate dBallJoint; typedef dHingeJointTemplate dHingeJoint; typedef dSliderJointTemplate dSliderJoint; typedef dUniversalJointTemplate dUniversalJoint; typedef dHinge2JointTemplate dHinge2Joint; typedef dPRJointTemplate dPRJoint; typedef dPUJointTemplate dPUJoint; typedef dPistonJointTemplate dPistonJoint; typedef dFixedJointTemplate dFixedJoint; typedef dContactJointTemplate dContactJoint; typedef dNullJointTemplate dNullJoint; typedef dAMotorJointTemplate dAMotorJoint; typedef dLMotorJointTemplate dLMotorJoint; #endif #endif // Local variables: // mode:c++ // c-basic-offset:2 // End: