703 lines
21 KiB
C++
703 lines
21 KiB
C++
/*************************************************************************
|
|
* *
|
|
* 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 <ode/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
|