--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/classicui_plat/ode_api/inc/odecpp.h Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,702 @@
+/*************************************************************************
+ * *
+ * 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
+
+#include "error.h"
+
+
+class dWorld {
+ dWorldID _id;
+
+ // intentionally undefined, don't use these
+ dWorld (const dWorld &);
+ void operator= (const dWorld &);
+
+public:
+ dWorld()
+ { _id = dWorldCreate(); }
+ ~dWorld()
+ { dWorldDestroy (_id); }
+
+ dWorldID id() const
+ { return _id; }
+ operator dWorldID() const
+ { return _id; }
+
+ void setGravity (dReal x, dReal y, dReal z)
+ { dWorldSetGravity (_id,x,y,z); }
+ void getGravity (dVector3 g) const
+ { dWorldGetGravity (_id,g); }
+
+ void setERP (dReal erp)
+ { dWorldSetERP(_id, erp); }
+ dReal getERP() const
+ { return dWorldGetERP(_id); }
+
+ void setCFM (dReal cfm)
+ { dWorldSetCFM(_id, cfm); }
+ dReal getCFM() const
+ { return dWorldGetCFM(_id); }
+
+ void step (dReal stepsize)
+ { dWorldStep (_id,stepsize); }
+
+ void stepFast1 (dReal stepsize, int maxiterations)
+ { dWorldStepFast1 (_id,stepsize,maxiterations); }
+ void setAutoEnableDepthSF1(dWorldID, int depth)
+ { dWorldSetAutoEnableDepthSF1 (_id, depth); }
+ int getAutoEnableDepthSF1(dWorldID)
+ { return dWorldGetAutoEnableDepthSF1 (_id); }
+
+ void setAutoDisableLinearThreshold (dReal threshold)
+ { dWorldSetAutoDisableLinearThreshold (_id,threshold); }
+ dReal getAutoDisableLinearThreshold()
+ { return dWorldGetAutoDisableLinearThreshold (_id); }
+ void setAutoDisableAngularThreshold (dReal threshold)
+ { dWorldSetAutoDisableAngularThreshold (_id,threshold); }
+ dReal getAutoDisableAngularThreshold()
+ { return dWorldGetAutoDisableAngularThreshold (_id); }
+ void setAutoDisableSteps (int steps)
+ { dWorldSetAutoDisableSteps (_id,steps); }
+ int getAutoDisableSteps()
+ { return dWorldGetAutoDisableSteps (_id); }
+ void setAutoDisableTime (dReal time)
+ { dWorldSetAutoDisableTime (_id,time); }
+ dReal getAutoDisableTime()
+ { return dWorldGetAutoDisableTime (_id); }
+ void setAutoDisableFlag (int do_auto_disable)
+ { dWorldSetAutoDisableFlag (_id,do_auto_disable); }
+ int getAutoDisableFlag()
+ { return dWorldGetAutoDisableFlag (_id); }
+
+ void impulseToForce (dReal stepsize, dReal ix, dReal iy, dReal iz,
+ dVector3 force)
+ { dWorldImpulseToForce (_id,stepsize,ix,iy,iz,force); }
+};
+
+
+class dBody {
+ dBodyID _id;
+
+ // intentionally undefined, don't use these
+ dBody (const dBody &);
+ void operator= (const dBody &);
+
+public:
+ dBody()
+ { _id = 0; }
+ dBody (dWorldID world)
+ { _id = dBodyCreate (world); }
+ ~dBody()
+ { if (_id) dBodyDestroy (_id); }
+
+ void create (dWorldID world) {
+ if (_id) dBodyDestroy (_id);
+ _id = dBodyCreate (world);
+ }
+
+ dBodyID id() const
+ { return _id; }
+ operator dBodyID() const
+ { return _id; }
+
+ void setData (void *data)
+ { dBodySetData (_id,data); }
+ void *getData() const
+ { return dBodyGetData (_id); }
+
+ void setPosition (dReal x, dReal y, dReal z)
+ { dBodySetPosition (_id,x,y,z); }
+ void setRotation (const dMatrix3 R)
+ { dBodySetRotation (_id,R); }
+ void setQuaternion (const dQuaternion q)
+ { dBodySetQuaternion (_id,q); }
+ void setLinearVel (dReal x, dReal y, dReal z)
+ { dBodySetLinearVel (_id,x,y,z); }
+ void setAngularVel (dReal x, dReal y, dReal z)
+ { dBodySetAngularVel (_id,x,y,z); }
+
+ const dReal * getPosition() const
+ { return dBodyGetPosition (_id); }
+ const dReal * getRotation() const
+ { return dBodyGetRotation (_id); }
+ const dReal * getQuaternion() const
+ { return dBodyGetQuaternion (_id); }
+ const dReal * getLinearVel() const
+ { return dBodyGetLinearVel (_id); }
+ const dReal * getAngularVel() const
+ { return dBodyGetAngularVel (_id); }
+
+ void setMass (const dMass *mass)
+ { dBodySetMass (_id,mass); }
+ void getMass (dMass *mass) const
+ { dBodyGetMass (_id,mass); }
+
+ void addForce (dReal fx, dReal fy, dReal fz)
+ { dBodyAddForce (_id, fx, fy, fz); }
+ void addTorque (dReal fx, dReal fy, dReal fz)
+ { dBodyAddTorque (_id, fx, fy, fz); }
+ void addRelForce (dReal fx, dReal fy, dReal fz)
+ { dBodyAddRelForce (_id, fx, fy, fz); }
+ void addRelTorque (dReal fx, dReal fy, dReal fz)
+ { dBodyAddRelTorque (_id, fx, fy, fz); }
+ void addForceAtPos (dReal fx, dReal fy, dReal fz,
+ dReal px, dReal py, dReal pz)
+ { dBodyAddForceAtPos (_id, fx, fy, fz, px, py, pz); }
+ void addForceAtRelPos (dReal fx, dReal fy, dReal fz,
+ dReal px, dReal py, dReal pz)
+ { dBodyAddForceAtRelPos (_id, fx, fy, fz, px, py, pz); }
+ void addRelForceAtPos (dReal fx, dReal fy, dReal fz,
+ dReal px, dReal py, dReal pz)
+ { dBodyAddRelForceAtPos (_id, fx, fy, fz, px, py, pz); }
+ void addRelForceAtRelPos (dReal fx, dReal fy, dReal fz,
+ dReal px, dReal py, dReal pz)
+ { dBodyAddRelForceAtRelPos (_id, fx, fy, fz, px, py, pz); }
+
+ const dReal * getForce() const
+ { return dBodyGetForce(_id); }
+ const dReal * getTorque() const
+ { return dBodyGetTorque(_id); }
+ void setForce (dReal x, dReal y, dReal z)
+ { dBodySetForce (_id,x,y,z); }
+ void setTorque (dReal x, dReal y, dReal z)
+ { dBodySetTorque (_id,x,y,z); }
+
+ void enable()
+ { dBodyEnable (_id); }
+ void disable()
+ { dBodyDisable (_id); }
+ int isEnabled() const
+ { return dBodyIsEnabled (_id); }
+
+ void getRelPointPos (dReal px, dReal py, dReal pz, dVector3 result) const
+ { dBodyGetRelPointPos (_id, px, py, pz, result); }
+ void getRelPointVel (dReal px, dReal py, dReal pz, dVector3 result) const
+ { dBodyGetRelPointVel (_id, px, py, pz, result); }
+ void getPointVel (dReal px, dReal py, dReal pz, dVector3 result) const
+ { dBodyGetPointVel (_id,px,py,pz,result); }
+ void getPosRelPoint (dReal px, dReal py, dReal pz, dVector3 result) const
+ { dBodyGetPosRelPoint (_id,px,py,pz,result); }
+ void vectorToWorld (dReal px, dReal py, dReal pz, dVector3 result) const
+ { dBodyVectorToWorld (_id,px,py,pz,result); }
+ void vectorFromWorld (dReal px, dReal py, dReal pz, dVector3 result) const
+ { dBodyVectorFromWorld (_id,px,py,pz,result); }
+
+ void setFiniteRotationMode (int mode)
+ { dBodySetFiniteRotationMode (_id, mode); }
+ void setFiniteRotationAxis (dReal x, dReal y, dReal z)
+ { dBodySetFiniteRotationAxis (_id, x, y, z); }
+
+ int getFiniteRotationMode() const
+ { return dBodyGetFiniteRotationMode (_id); }
+ void getFiniteRotationAxis (dVector3 result) const
+ { dBodyGetFiniteRotationAxis (_id, result); }
+
+ int getNumJoints() const
+ { return dBodyGetNumJoints (_id); }
+ dJointID getJoint (int index) const
+ { return dBodyGetJoint (_id, index); }
+
+ void setGravityMode (int mode)
+ { dBodySetGravityMode (_id,mode); }
+ int getGravityMode() const
+ { return dBodyGetGravityMode (_id); }
+
+ int isConnectedTo (dBodyID body) const
+ { return dAreConnected (_id, body); }
+
+ void setAutoDisableLinearThreshold (dReal threshold)
+ { dBodySetAutoDisableLinearThreshold (_id,threshold); }
+ dReal getAutoDisableLinearThreshold()
+ { return dBodyGetAutoDisableLinearThreshold (_id); }
+ void setAutoDisableAngularThreshold (dReal threshold)
+ { dBodySetAutoDisableAngularThreshold (_id,threshold); }
+ dReal getAutoDisableAngularThreshold()
+ { return dBodyGetAutoDisableAngularThreshold (_id); }
+ void setAutoDisableSteps (int steps)
+ { dBodySetAutoDisableSteps (_id,steps); }
+ int getAutoDisableSteps()
+ { return dBodyGetAutoDisableSteps (_id); }
+ void setAutoDisableTime (dReal time)
+ { dBodySetAutoDisableTime (_id,time); }
+ dReal getAutoDisableTime()
+ { return dBodyGetAutoDisableTime (_id); }
+ void setAutoDisableFlag (int do_auto_disable)
+ { dBodySetAutoDisableFlag (_id,do_auto_disable); }
+ int getAutoDisableFlag()
+ { return dBodyGetAutoDisableFlag (_id); }
+};
+
+
+class dJointGroup {
+ dJointGroupID _id;
+
+ // intentionally undefined, don't use these
+ dJointGroup (const dJointGroup &);
+ void operator= (const dJointGroup &);
+
+public:
+ dJointGroup (int dummy_arg=0)
+ { _id = dJointGroupCreate (0); }
+ ~dJointGroup()
+ { dJointGroupDestroy (_id); }
+ void create (int dummy_arg=0) {
+ if (_id) dJointGroupDestroy (_id);
+ _id = dJointGroupCreate (0);
+ }
+
+ dJointGroupID id() const
+ { return _id; }
+ operator dJointGroupID() const
+ { return _id; }
+
+ void empty()
+ { dJointGroupEmpty (_id); }
+};
+
+
+class dJoint {
+private:
+ // intentionally undefined, don't use these
+ dJoint (const dJoint &) ;
+ void operator= (const dJoint &);
+
+protected:
+ dJointID _id;
+
+public:
+ dJoint()
+ { _id = 0; }
+ ~dJoint()
+ { if (_id) dJointDestroy (_id); }
+
+ dJointID id() const
+ { return _id; }
+ operator dJointID() const
+ { return _id; }
+
+ void attach (dBodyID body1, dBodyID body2)
+ { dJointAttach (_id, body1, body2); }
+
+ void setData (void *data)
+ { dJointSetData (_id, data); }
+ void *getData() const
+ { return dJointGetData (_id); }
+
+ int getType() const
+ { return dJointGetType (_id); }
+
+ dBodyID getBody (int index) const
+ { return dJointGetBody (_id, index); }
+
+ void setFeedback(dJointFeedback *fb)
+ { dJointSetFeedback(_id, fb); }
+ dJointFeedback *getFeedback() const
+ { return dJointGetFeedback(_id); }
+};
+
+
+class dBallJoint : public dJoint {
+private:
+ // intentionally undefined, don't use these
+ dBallJoint (const dBallJoint &);
+ void operator= (const dBallJoint &);
+
+public:
+ dBallJoint() { }
+ dBallJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateBall (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateBall (world, group);
+ }
+
+ void setAnchor (dReal x, dReal y, dReal z)
+ { dJointSetBallAnchor (_id, x, y, z); }
+ void getAnchor (dVector3 result) const
+ { dJointGetBallAnchor (_id, result); }
+ void getAnchor2 (dVector3 result) const
+ { dJointGetBallAnchor2 (_id, result); }
+} ;
+
+
+class dHingeJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dHingeJoint (const dHingeJoint &);
+ void operator = (const dHingeJoint &);
+
+public:
+ dHingeJoint() { }
+ dHingeJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateHinge (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateHinge (world, group);
+ }
+
+ void setAnchor (dReal x, dReal y, dReal z)
+ { dJointSetHingeAnchor (_id, x, y, z); }
+ void getAnchor (dVector3 result) const
+ { dJointGetHingeAnchor (_id, result); }
+ void getAnchor2 (dVector3 result) const
+ { dJointGetHingeAnchor2 (_id, result); }
+
+ void setAxis (dReal x, dReal y, dReal z)
+ { dJointSetHingeAxis (_id, x, y, z); }
+ void getAxis (dVector3 result) const
+ { dJointGetHingeAxis (_id, result); }
+
+ dReal getAngle() const
+ { return dJointGetHingeAngle (_id); }
+ dReal getAngleRate() const
+ { return dJointGetHingeAngleRate (_id); }
+
+ void setParam (int parameter, dReal value)
+ { dJointSetHingeParam (_id, parameter, value); }
+ dReal getParam (int parameter) const
+ { return dJointGetHingeParam (_id, parameter); }
+
+ void addTorque (dReal torque)
+ { dJointAddHingeTorque(_id, torque); }
+};
+
+
+class dSliderJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dSliderJoint (const dSliderJoint &);
+ void operator = (const dSliderJoint &);
+
+public:
+ dSliderJoint() { }
+ dSliderJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateSlider (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateSlider (world, group);
+ }
+
+ void setAxis (dReal x, dReal y, dReal z)
+ { dJointSetSliderAxis (_id, x, y, z); }
+ void getAxis (dVector3 result) const
+ { dJointGetSliderAxis (_id, result); }
+
+ dReal getPosition() const
+ { return dJointGetSliderPosition (_id); }
+ dReal getPositionRate() const
+ { return dJointGetSliderPositionRate (_id); }
+
+ void setParam (int parameter, dReal value)
+ { dJointSetSliderParam (_id, parameter, value); }
+ dReal getParam (int parameter) const
+ { return dJointGetSliderParam (_id, parameter); }
+
+ void addForce (dReal force)
+ { dJointAddSliderForce(_id, force); }
+};
+
+
+class dUniversalJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dUniversalJoint (const dUniversalJoint &);
+ void operator = (const dUniversalJoint &);
+
+public:
+ dUniversalJoint() { }
+ dUniversalJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateUniversal (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateUniversal (world, group);
+ }
+
+ void setAnchor (dReal x, dReal y, dReal z)
+ { dJointSetUniversalAnchor (_id, x, y, z); }
+ void setAxis1 (dReal x, dReal y, dReal z)
+ { dJointSetUniversalAxis1 (_id, x, y, z); }
+ void setAxis2 (dReal x, dReal y, dReal z)
+ { dJointSetUniversalAxis2 (_id, x, y, z); }
+ void setParam (int parameter, dReal value)
+ { dJointSetUniversalParam (_id, parameter, value); }
+
+ void getAnchor (dVector3 result) const
+ { dJointGetUniversalAnchor (_id, result); }
+ void getAnchor2 (dVector3 result) const
+ { dJointGetUniversalAnchor2 (_id, result); }
+ void getAxis1 (dVector3 result) const
+ { dJointGetUniversalAxis1 (_id, result); }
+ void getAxis2 (dVector3 result) const
+ { dJointGetUniversalAxis2 (_id, result); }
+ dReal getParam (int parameter) const
+ { return dJointGetUniversalParam (_id, parameter); }
+ void getAngles(dReal *angle1, dReal *angle2) const
+ { dJointGetUniversalAngles (_id, angle1, angle2); }
+
+ dReal getAngle1() const
+ { return dJointGetUniversalAngle1 (_id); }
+ dReal getAngle1Rate() const
+ { return dJointGetUniversalAngle1Rate (_id); }
+ dReal getAngle2() const
+ { return dJointGetUniversalAngle2 (_id); }
+ dReal getAngle2Rate() const
+ { return dJointGetUniversalAngle2Rate (_id); }
+
+ void addTorques (dReal torque1, dReal torque2)
+ { dJointAddUniversalTorques(_id, torque1, torque2); }
+};
+
+
+class dHinge2Joint : public dJoint {
+ // intentionally undefined, don't use these
+ dHinge2Joint (const dHinge2Joint &);
+ void operator = (const dHinge2Joint &);
+
+public:
+ dHinge2Joint() { }
+ dHinge2Joint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateHinge2 (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateHinge2 (world, group);
+ }
+
+ void setAnchor (dReal x, dReal y, dReal z)
+ { dJointSetHinge2Anchor (_id, x, y, z); }
+ void setAxis1 (dReal x, dReal y, dReal z)
+ { dJointSetHinge2Axis1 (_id, x, y, z); }
+ void setAxis2 (dReal x, dReal y, dReal z)
+ { dJointSetHinge2Axis2 (_id, x, y, z); }
+
+ void getAnchor (dVector3 result) const
+ { dJointGetHinge2Anchor (_id, result); }
+ void getAnchor2 (dVector3 result) const
+ { dJointGetHinge2Anchor2 (_id, result); }
+ void getAxis1 (dVector3 result) const
+ { dJointGetHinge2Axis1 (_id, result); }
+ void getAxis2 (dVector3 result) const
+ { dJointGetHinge2Axis2 (_id, result); }
+
+ dReal getAngle1() const
+ { return dJointGetHinge2Angle1 (_id); }
+ dReal getAngle1Rate() const
+ { return dJointGetHinge2Angle1Rate (_id); }
+ dReal getAngle2Rate() const
+ { return dJointGetHinge2Angle2Rate (_id); }
+
+ void setParam (int parameter, dReal value)
+ { dJointSetHinge2Param (_id, parameter, value); }
+ dReal getParam (int parameter) const
+ { return dJointGetHinge2Param (_id, parameter); }
+
+ void addTorques(dReal torque1, dReal torque2)
+ { dJointAddHinge2Torques(_id, torque1, torque2); }
+};
+
+
+class dPRJoint : public dJoint {
+ dPRJoint (const dPRJoint &);
+ void operator = (const dPRJoint &);
+
+public:
+ dPRJoint() { }
+ dPRJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreatePR (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreatePR (world, group);
+ }
+
+ void setAnchor (dReal x, dReal y, dReal z)
+ { dJointSetPRAnchor (_id, x, y, z); }
+ void setAxis1 (dReal x, dReal y, dReal z)
+ { dJointSetPRAxis1 (_id, x, y, z); }
+ void setAxis2 (dReal x, dReal y, dReal z)
+ { dJointSetPRAxis2 (_id, x, y, z); }
+
+ void getAnchor (dVector3 result) const
+ { dJointGetPRAnchor (_id, result); }
+ void getAxis1 (dVector3 result) const
+ { dJointGetPRAxis1 (_id, result); }
+ void getAxis2 (dVector3 result) const
+ { dJointGetPRAxis2 (_id, result); }
+
+ dReal getPosition() const
+ { return dJointGetPRPosition (_id); }
+ dReal getPositionRate() const
+ { return dJointGetPRPositionRate (_id); }
+
+ void setParam (int parameter, dReal value)
+ { dJointSetPRParam (_id, parameter, value); }
+ dReal getParam (int parameter) const
+ { return dJointGetPRParam (_id, parameter); }
+};
+
+
+class dFixedJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dFixedJoint (const dFixedJoint &);
+ void operator = (const dFixedJoint &);
+
+public:
+ dFixedJoint() { }
+ dFixedJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateFixed (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateFixed (world, group);
+ }
+
+ void set()
+ { dJointSetFixed (_id); }
+};
+
+
+class dContactJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dContactJoint (const dContactJoint &);
+ void operator = (const dContactJoint &);
+
+public:
+ dContactJoint() { }
+ dContactJoint (dWorldID world, dJointGroupID group, dContact *contact)
+ { _id = dJointCreateContact (world, group, contact); }
+
+ void create (dWorldID world, dJointGroupID group, dContact *contact) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateContact (world, group, contact);
+ }
+};
+
+
+class dNullJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dNullJoint (const dNullJoint &);
+ void operator = (const dNullJoint &);
+
+public:
+ dNullJoint() { }
+ dNullJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateNull (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateNull (world, group);
+ }
+};
+
+
+class dAMotorJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dAMotorJoint (const dAMotorJoint &);
+ void operator = (const dAMotorJoint &);
+
+public:
+ dAMotorJoint() { }
+ dAMotorJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateAMotor (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateAMotor (world, group);
+ }
+
+ void setMode (int mode)
+ { dJointSetAMotorMode (_id, mode); }
+ int getMode() const
+ { return dJointGetAMotorMode (_id); }
+
+ void setNumAxes (int num)
+ { dJointSetAMotorNumAxes (_id, num); }
+ int getNumAxes() const
+ { return dJointGetAMotorNumAxes (_id); }
+
+ void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
+ { dJointSetAMotorAxis (_id, anum, rel, x, y, z); }
+ void getAxis (int anum, dVector3 result) const
+ { dJointGetAMotorAxis (_id, anum, result); }
+ int getAxisRel (int anum) const
+ { return dJointGetAMotorAxisRel (_id, anum); }
+
+ void setAngle (int anum, dReal angle)
+ { dJointSetAMotorAngle (_id, anum, angle); }
+ dReal getAngle (int anum) const
+ { return dJointGetAMotorAngle (_id, anum); }
+ dReal getAngleRate (int anum)
+ { return dJointGetAMotorAngleRate (_id,anum); }
+
+ void setParam (int parameter, dReal value)
+ { dJointSetAMotorParam (_id, parameter, value); }
+ dReal getParam (int parameter) const
+ { return dJointGetAMotorParam (_id, parameter); }
+
+ void addTorques(dReal torque1, dReal torque2, dReal torque3)
+ { dJointAddAMotorTorques(_id, torque1, torque2, torque3); }
+};
+
+
+class dLMotorJoint : public dJoint {
+ // intentionally undefined, don't use these
+ dLMotorJoint (const dLMotorJoint &);
+ void operator = (const dLMotorJoint &);
+
+public:
+ dLMotorJoint() { }
+ dLMotorJoint (dWorldID world, dJointGroupID group=0)
+ { _id = dJointCreateLMotor (world, group); }
+
+ void create (dWorldID world, dJointGroupID group=0) {
+ if (_id) dJointDestroy (_id);
+ _id = dJointCreateLMotor (world, group);
+ }
+
+ void setNumAxes (int num)
+ { dJointSetLMotorNumAxes (_id, num); }
+ int getNumAxes() const
+ { return dJointGetLMotorNumAxes (_id); }
+
+ void setAxis (int anum, int rel, dReal x, dReal y, dReal z)
+ { dJointSetLMotorAxis (_id, anum, rel, x, y, z); }
+ void getAxis (int anum, dVector3 result) const
+ { dJointGetLMotorAxis (_id, anum, result); }
+
+ void setParam (int parameter, dReal value)
+ { dJointSetLMotorParam (_id, parameter, value); }
+ dReal getParam (int parameter) const
+ { return dJointGetLMotorParam (_id, parameter); }
+};
+
+
+
+#endif
+#endif