 dAreConnected | Test if the two specified bodies are connected by a joint. Return 1 if yes, otherwise return 0 |
 dAreConnectedExcluding | Return 1 if the two bodies are connected together by a joint that does not have type joint_type, otherwise return 0. joint_type is a dJointTypeXXX constant. This is useful for deciding whether to add contact joints between two bodies: if they are already connected by non-contact joints then it may not be appropriate to add contacts, however it is okay to add more contact between bodies that already have contacts. |
 dBodyAddForce | Add force to a body using absolute coordinates. |
 dBodyAddForceAtPos | Add force to a body using absolute coordinates at specified absolute position. The supplied position vector specifies the point at which the force is supplied in global coordinates. |
 dBodyAddForceAtRelPos | Add force to a body using absolute coordinates at specified relative position. The supplied position vector specifies the point at which the force is supplied in body-relative coordinates. |
 dBodyAddRelForce | Add force to a body using relative coordinates. This function takes a force vector that is relative to the body's own frame of reference. |
 dBodyAddRelForceAtPos | Add force to a body using body-relative coordinates at specified absolute position. The supplied position vector specifies the point at which the force is supplied in global coordinates. |
 dBodyAddRelForceAtRelPos | Add force to a body using body-relative coordinates at specified relative position. The supplied position vector specifies the point at which the force is supplied in body-relative coordinates. |
 dBodyAddRelTorque | Add torque to a body using relative coordinates. This function takes a force vector that is relative to the body's own frame of reference. |
 dBodyAddTorque | Add torque to a body using absolute coordinates. |
 dBodyCreate | Create a body in the given world with default mass parameters at position (0,0,0). Return its ID (really a handle to the body). |
 dBodyDestroy | Destroy a body. All joints that are attached to this body will be put into limbo (i.e. unattached and not affecting the simulation, but they will NOT be deleted) |
 dBodyDisable | Manually disable a body. Note that a disabled body that is connected through a joint to an enabled body will be automatically re-enabled at the next simulation step. |
 dBodyEnable | Manually enable a body. Note that a disabled body that is connected through a joint to an enabled body will be automatically re-enabled at the next simulation step. |
 dBodyGetAngularVel | Get the angular velocity of a body The vector is valid until any changes are made to the rigid body system structure. |
 dBodyGetAutoDisableAngularThreshold | Method dBodyGetAutoDisableAngularThreshold Get a body's angular velocity threshold for automatic disabling. The body's linear angular magnitude must be less than this threshold for it to be considered idle. Set the threshold to dInfinity to prevent the angular velocity from being considered. |
 dBodyGetAutoDisableFlag | Method dBodyGetAutoDisableFlag Get the auto-disable flag of a body. If the do_auto_disable is nonzero the body will be automatically disabled when it has been idle for long enough. |
 dBodyGetAutoDisableLinearThreshold | Method dBodyGetAutoDisableLinearThreshold Get a body's linear velocity threshold for automatic disabling. The body's linear velocity magnitude must be less than this threshold for it to be considered idle. Set the threshold to dInfinity to prevent the linear velocity from being considered. |
 dBodyGetAutoDisableSteps | Method dBodyGetAutoDisableSteps Get the number of simulation steps that a body must be idle before it is automatically disabled. If zero, consideration of the number of steps is disabled. |
 dBodyGetAutoDisableTime | Method dBodyGetAutoDisableTime Get the amount of simulation time that a body must be idle before it is automatically disabled. If zero, consideration of the amount of simulation time is disabled. |
 dBodyGetData | Get the body's user-data pointer. |
 dBodyGetFiniteRotationAxis | Return the current finite rotation axis of a body. |
 dBodyGetFiniteRotationMode | Return the current finite rotation mode of a body (0 or 1). |
 dBodyGetForce | Return the current accumulated force on the body. |
 dBodyGetGravityMode | Get whether the body is influenced by the world's gravity or not. If mode is nonzero it is, if mode is zero, it isn't. |
 dBodyGetJoint | Return a joint attached to this body, given by index. Valid indexes are 0 to n-1 where n is the value returned by dBodyGetNumJoints. |
 dBodyGetLinearVel | Get the linear velocity of a body The vector is valid until any changes are made to the rigid body system structure. |
 dBodyGetMass | Get the mass of the body (see the mass functions) |
 dBodyGetNumJoints | Return the number of joints that are attached to this body. |
 dBodyGetPointVel | Take a point on a body (px,py,pz) and return that point's position in absolute coordinates (in result). |
 dBodyGetPosition | Get the position of the body The vector is valid until any changes are made to the rigid body system structure. |
 dBodyGetPosRelPoint | This is the inverse of dBodyGetRelPointPos. It takes a point in global coordinates (x,y,z) and returns the point's position in body-relative coordinates (result). |
 dBodyGetQuaternion | Get the orientation of a body. Orientation is represented by a quaternion (qs,qx,qy,qz) |
 dBodyGetRelPointPos | Take a point on a body (px,py,pz) and return that point's position in body-relative coordinates (in result). |
 dBodyGetRelPointVel | Take a point on a body (px,py,pz) and return that point's velocity in body-relative coordinates (in result). |
 dBodyGetRotation | Get the rotation of the body. The returned value is a 4x3 rotation matrix. The matrix is valid until any changes are made to the rigid body system structure. |
 dBodyGetTorque | Return the current accumulated torque on the body. |
 dBodyIsEnabled | Method dBodyIsEnabled Return 1 if a body is currently enabled or 0 if it is disabled. |
 dBodySetAngularVel | Set the angular velocity of the body. After setting a group of bodies, the outcome of the simulation is undefined if the new configuration is inconsistent with the joints/constraints that are present. |
 dBodySetAutoDisableAngularThreshold | Method dBodySetAutoDisableAngularThreshold Set a body's angular velocity threshold for automatic disabling. The body's linear angular magnitude must be less than this threshold for it to be considered idle. Set the threshold to dInfinity to prevent the angular velocity from being considered. |
 dBodySetAutoDisableDefaults | Method dBodySetAutoDisableDefaults Set the auto-disable parameters of the body to the default parameters that have been set on the world. |
 dBodySetAutoDisableFlag | Method dBodySetAutoDisableFlag Set the auto-disable flag of a body. If the do_auto_disable is nonzero the body will be automatically disabled when it has been idle for long enough. |
 dBodySetAutoDisableLinearThreshold | Method dBodySetAutoDisableLinearThreshold Set a body's linear velocity threshold for automatic disabling. The body's linear velocity magnitude must be less than this threshold for it to be considered idle. Set the threshold to dInfinity to prevent the linear velocity from being considered. |
 dBodySetAutoDisableSteps | Method dBodySetAutoDisableSteps Set the number of simulation steps that a body must be idle before it is automatically disabled. Set this to zero to disable consideration of the number of steps. |
 dBodySetAutoDisableTime | Method dBodySetAutoDisableTime Set the amount of simulation time that a body must be idle before it is automatically disabled. Set this to zero to disable consideration of the amount of simulation time. |
 dBodySetData | Set the body's user-data pointer. |
 dBodySetFiniteRotationAxis | This sets the finite rotation axis for a body. This axis only has meaning when the finite rotation mode is set (see dBodySetFiniteRotationMode). If this axis is zero (0,0,0), full finite rotations are performed on the body. If this axis is nonzero, the body is rotated by performing a partial finite rotation along the axis direction followed by an infinitesimal rotation along an orthogonal direction. This can be useful to alleviate certain sources of error caused by quickly spinning bodies. For example, if a car wheel is rotating at high speed you can call this function with the wheel's hinge axis as the argument to try and improve its behavior. |
 dBodySetFiniteRotationMode | This function controls the way a body's orientation is updated at each time step. The mode argument can be: - 0: An ``infinitesimal'' orientation update is used. This is fast to compute, but it can occasionally cause inaccuracies for bodies that are rotating at high speed, especially when those bodies are joined to other bodies. This is the default for every new body that is created. - 1: A ``finite'' orientation update is used. This is more costly to compute, but will be more accurate for high speed rotations. Note however that high speed rotations can result in many types of error in a simulation, and this mode will only fix one of those sources of error. |
 dBodySetForce | Set the body force accumulation vector. This is mostly useful to zero the force and torque for deactivated bodies before they are reactivated, in the case where the force-adding functions were called on them while they were deactivated. |
 dBodySetGravityMode | Set whether the body is influenced by the world's gravity or not. If mode is nonzero it is, if mode is zero, it isn't. Newly created bodies are always influenced by the world's gravity. |
 dBodySetLinearVel | Set the linear velocity of the body. After setting a group of bodies, the outcome of the simulation is undefined if the new configuration is inconsistent with the joints/constraints that are present. |
 dBodySetMass | Set the mass of the body (see the mass functions) |
 dBodySetPosition | Set the position of the body. After setting a group of bodies, the outcome of the simulation is undefined if the new configuration is inconsistent with the joints/constraints that are present. |
 dBodySetQuaternion | Set the orientation on of the body. Orientation is represented by a quaternion (qs,qx,qy,qz) After setting a group of bodies, the outcome of the simulation is undefined if the new configuration is inconsistent with the joints/constraints that are present. |
 dBodySetRotation | Overloaded. Set the rotation of the body. After setting a group of bodies, the outcome of the simulation is undefined if the new configuration is inconsistent with the joints/constraints that are present. |
 dBodySetTorque | Set the body torque accumulation vector. This is mostly useful to zero the force and torque for deactivated bodies before they are reactivated, in the case where the force-adding functions were called on them while they were deactivated. |
 dBodyVectorFromWorld | Given a vector expressed in the world coordinate system (x,y,z), rotate it to the body coordinate system (result). |
 dBodyVectorToWorld | Given a vector expressed in the body coordinate system (x,y,z), rotate it to the world coordinate system (result). |
 dBoxBox | given two boxes (p1,R1,side1) and (p2,R2,side2), collide them together and generate contact points. this returns 0 if there is no contact otherwise it returns the number of contacts generated. `normal' returns the contact normal. `depth' returns the maximum penetration depth along that normal. `return_code' returns a number indicating the type of contact that was detected: 1,2,3 = box 2 intersects with a face of box 1 4,5,6 = box 1 intersects with a face of box 2 7..15 = edge-edge contact `maxc' is the maximum number of contacts allowed to be generated, i.e. the size of the `contact' array. `contact' and `skip' are the contact array information provided to the collision functions. this function only fills in the position and depth fields. |
 dBoxTouchesBox | Given boxes (p1,R1,side1) and (p2,R2,side2), return 1 if they intersect or 0 if not. p is the center of the box, R is the rotation matrix for the box, and side is a vector of x/y/z side lengths. |
 dCloseODE | This deallocates some extra memory used by ODE that can not be deallocated using the normal destroy functions, e.g. dWorldDestroy. You can use this function at the end of your application to prevent memory leak checkers from complaining about ODE. |
 dClosestLineSegmentPoints | Given two line segments A and B with endpoints a1-a2 and b1-b2, return the points on A and B that are closest to each other (in cp1 and cp2). In the case of parallel lines where there are multiple solutions, a solution involving the endpoint of at least one line will be returned. This will work correctly for zero length lines, e.g. if a1==a2 and/or b1==b2. |
 dCollide | Given two geoms o1 and o2 that potentially intersect, generate contact information for them. Internally, this just calls the correct class-specific collision functions for o1 and o2. "flags" specifies how contacts should be generated if the geoms touch. The lower 16 bits of flags is an integer that specifies the maximum number of contact points to generate. Note that if this number is zero, this function just pretends that it is one - in other words you can not ask for zero contacts. All other bits in flags must be zero. In the future the other bits may be used to select from different contact generation strategies. "contacts" points to an array of dContactGeom structures. The array must be able to hold at least the maximum number of contacts. These dContactGeom structures may be embedded within larger structures in the array - the skip parameter is the byte offset from one dContactGeom to the next in the array. If skip is sizeof(dContactGeom) then contact points to a normal (C-style) array. It is an error for skip to be smaller than sizeof(dContactGeom). If the geoms intersect, this function returns the number of contact points generated (and updates the contact array), otherwise it returns 0 (and the contact array is not touched). If a space is passed as o1 or o2 then this function will collide all objects contained in o1 with all objects contained in o2, and return the resulting contact points. This method for colliding spaces with geoms (or spaces with spaces) provides no user control over the individual collisions. To get that control, use dSpaceCollide or dSpaceCollide2 instead. If o1 and o2 are the same geom then this function will do nothing and return 0. Technically speaking an object intersects with itself, but it is not useful to find contact points in this case. This function does not care if o1 and o2 are in the same space or not (or indeed if they are in any space at all). |
 dConnectingJoint | Undocumented in ODE. Seems to return the first joint connecting the two specified bodies |
 dConnectingJointList | Undocumented in ODE. Seems to return a list of the joints connecting the two specified bodies |
 dCreateBox | Create a box geom of the given x/y/z side lengths (lx,ly,lz), and return its ID. If space is nonzero, insert it into that space. The point of reference for a box is its center. |
 dCreateCapsule | Create a capsule geom of the given parameters, and return its ID. If space is nonzero, insert it into that space. A capsule is like a normal cylinder except it has half-sphere caps at its ends. This feature makes the internal collision detection code particularly fast and accurate. The cylinder's length, not counting the caps, is given by length. The cylinder is aligned along the geom's local Z axis. The radius of the caps, and of the cylinder itself, is given by radius. |
 dCreateCylinder | Create a (flat-ended) cylinder geom of the given parameters, and return its ID. If space is nonzero, insert it into that space. The cylinder's length is given by length. The cylinder is aligned along the geom's local Z axis. The radius of the cylinder is given by radius. |
 dCreateGeomTransform | Create a new geometry transform object, and return its ID. NOTE: The new Geometry offset API is favored over transforms. If space is nonzero, insert it into that space. On creation the encapsulated geometry is set to 0. |
 dCreatePlane | Create a plane geom of the given parameters, and return its ID. If space is nonzero, insert it into that space. The plane equation is a*x+b*y+c*z = d The plane's normal vector is (a,b,c), and it must have length 1. Planes are non-placeable geoms. This means that, unlike placeable geoms, planes do not have an assigned position and rotation. This means that the parameters (a,b,c,d) are always in global coordinates. In other words it is assumed that the plane is always part of the static environment and not tied to any movable object. |
 dCreateRay | Create a ray geom of the given length, and return its ID. If space is nonzero, insert it into that space. |
 dCreateSphere | Create a sphere geom of the given radius, and return its ID. If space is nonzero, insert it into that space. The point of reference for a sphere is its center. |
 dCreateTriMesh | Trimesh class constructor. The Data member defines the vertex data the newly created triangle mesh will use. Callbacks are optional. |
 dGeomBoxGetLengths | Return in result the side lengths of the given box. |
 dGeomBoxPointDepth | Return the depth of the point (x,y,z) in the given box. Points inside the geom will have positive depth, points outside it will have negative depth, and points on the surface will have zero depth. |
 dGeomBoxSetLengths | Set the side lengths of the given box. |
 dGeomCapsuleGetParams | Return in radius and length the parameters of the given capsule. |
 dGeomCapsulePointDepth | Return the depth of the point (x,y,z) in the given capsule. Points inside the geom will have positive depth, points outside it will have negative depth, and points on the surface will have zero depth. |
 dGeomCapsuleSetParams | Set the parameters of the given capsule. |
 dGeomClearOffset | Clear any offset from the geom. If the geom has an offset, it is eliminated and the geom is repositioned at the body's position. If the geom has no offset, this function does nothing. This is more efficient than calling dGeomSetOffsetPosition(zero) and dGeomSetOffsetRotation(identiy), because this function actually eliminates the offset, rather than leaving it as the identity transform. |
 dGeomCylinderGetParams | Return in radius and length the parameters of the given cylinder. |
 dGeomCylinderSetParams | Set the parameters of the given cylinder. |
 dGeomDestroy | Destroy a geom, removing it from any space it is in first. This one function destroys a geom of any type, but to create a geom you must call a creation function for that type. When a space is destroyed, if its cleanup mode is 1 (the default) then all the geoms in that space are automatically destroyed as well. |
 dGeomDisable | Disable a geom. Disabled geoms are completely ignored by dSpaceCollide and dSpaceCollide2, although they can still be members of a space. New geoms are created in the enabled state. |
 dGeomEnable | Enable a geom. Disabled geoms are completely ignored by dSpaceCollide and dSpaceCollide2, although they can still be members of a space. New geoms are created in the enabled state. |
 dGeomGetAABB | Return in aabb an axis aligned bounding box that surrounds the given geom. The aabb array has elements (minx, maxx, miny, maxy, minz, maxz). If the geom is a space, a bounding box that surrounds all contained geoms is returned. This function may return a pre-computed cached bounding box, if it can determine that the geom has not moved since the last time the bounding box was computed. |
 dGeomGetBody | Get the body associated with a placeable geom. |
 dGeomGetCategoryBits | Get the "category" bitfield for the given geom. This bitfield is used by spaces to govern which geoms will interact with each other. The bitfield is guaranteed to be at least 32 bits wide. The default category and collide values for newly created geoms have all bits set. Note this is NOT CLS-compliant (due to the use of ulong to hold the 32-bit bitfield) TODO: Implement a CLS-compliant work-around or justify why not |
 dGeomGetClass | Given a geom, this returns its class number. The standard class numbers are: dSphereClass Sphere dBoxClass Box dCylinderClass Regular flat-ended cylinder dCapsuleClass Capped cylinder dPlaneClass Infinite plane (non-placeable) dRayClass Ray dConvexClass Convex class dGeomTransformClass Geometry transform dTriMeshClass Triangle mesh dSimpleSpaceClass Simple space dHashSpaceClass Hash table based space dQuadTreeSpaceClass Quad-tree based space dFirstUserClass First user class dLastUserClass Last user class User defined classes will return their own numbers. |
 dGeomGetCollideBits | Get the "collide" bitfield for the given geom. This bitfield is used by spaces to govern which geoms will interact with each other. The bitfield is guaranteed to be at least 32 bits wide. The default category and collide values for newly created geoms have all bits set. Note this is NOT CLS-compliant (due to the use of ulong to hold the 32-bit bitfield) TODO: Implement a CLS-compliant work-around or justify why not |
 dGeomGetData | Get the user-defined data pointer stored in the geom. WARNING: It is unclear from the ODE source and the documentation what the nature of user-data is. This function is here for the sake of completeness because it is part of ODE's public API, but has NOT been tested in any way. Use at own risk. |
 dGeomGetOffsetPosition | Get the offset position vector of a geom. Returns the positional offset of the geom in local coordinates. If the geom has no offset, this function returns the zero vector. |
 dGeomGetOffsetQuaternion | Get the offset rotation quaternion of a geom. Returns the rotation offset of the geom as a quaternion. If the geom has no offset, the identity quaternion is returned. |
 dGeomGetOffsetRotation | Get the offset rotation matrix of a geom. Returns the rotational offset of the geom as a matrix. If the geom has no offset, this function returns ???? FIXME - ODE docs incorrect. |
 dGeomGetPosition | Return the geom's position vector. In native ODE, the returned values are pointers to internal data structures, so the vectors are valid until any changes are made to the geom. If the geom is attached to a body, the body's position vector will be returned, i.e. the result will be identical to calling dBodyGetPosition dGeomGetQuaternion copies the geom's quaternion into the space provided. If the geom is attached to a body, the body's quaternion will be returned, i.e. the resulting quaternion will be the same as the result of calling dBodyGetQuaternion. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomGetQuaternion | Get the rotation quaternion of a placeable geom. dGeomGetQuaternion copies the geom's quaternion into the structure provided. If the geom is attached to a body, the body's quaternion will be returned, i.e. the resulting quaternion will be the same as the result of calling dBodyGetQuaternion. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomGetRotation | Get the rotation matrix of a placeable geom. In native ODE, the returned values are pointers to internal data structures, so the matrices are valid until any changes are made to the geom. If the geom is attached to a body, the body's rotation matrix will be returned, i.e. the result will be identical to calling dBodyGetRotation. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomGetSpace | Query for the space containing the specified geom. |
 dGeomIsEnabled | Check if a geom is enabled. New geoms are created in the enabled state. |
 dGeomIsOffset | Check to see whether the geom has an offset. This function will return non-zero if the offset has been created. Note that there is a difference between a geom with no offset, and a geom with an offset that is the identity transform. In the latter case, although the observed behaviour is identical, there is a unnecessary computation involved because the geom will be applying the transform whenever it needs to recalculate its world position. |
 dGeomIsSpace | Determine if a geom is a space. |
 dGeomPlaneGetParams | Return in result the parameters of the given plane. |
 dGeomPlanePointDepth | Return the depth of the point (x,y,z) in the given plane. Points inside the geom will have positive depth, points outside it will have negative depth, and points on the surface will have zero depth. |
 dGeomPlaneSetParams | Set the parameters of the given plane. |
 dGeomRayGet | Get the starting position (start) and direction (dir) of the ray. The returned direction will be a unit length vector. |
 dGeomRayGetClosestHit | Get the closest hit parameter for a ray TODO: Document me - not documented in ODE |
 dGeomRayGetLength | Get the length of the given ray. |
 dGeomRayGetParams | Overloaded. Get ray flags that influence ray collision detection. |
 dGeomRaySet | Set the starting position (px,py,pz) and direction (dx,dy,dz) of the given ray. The ray's rotation matrix will be adjusted so that the local Z-axis is aligned with the direction. Note that this does not adjust the ray's length. |
 dGeomRaySetClosestHit | Set the closest hit parameter for a ray TODO: Document me - not documented in ODE |
 dGeomRaySetLength | Set the length of the given ray. |
 dGeomRaySetParams | Set ray flags that influence ray collision detection. These flags are currently only noticed by the trimesh collider, because they can make a major difference there. |
 dGeomSetBody | Set the body associated with a placeable geom. Setting a body on a geom automatically combines the position vector and rotation matrix of the body and geom, so that setting the position or orientation of one will set the value for both objects. Setting a body ID of zero gives the geom its own position and rotation, independent from any body. If the geom was previously connected to a body then its new independent position/rotation is set to the current position/rotation of the body. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomSetCategoryBits | Set the "category" bitfield for the given geom. This bitfield is used by spaces to govern which geoms will interact with each other. The bitfield is guaranteed to be at least 32 bits wide. The default category and collide values for newly created geoms have all bits set. Note this is NOT CLS-compliant (due to the use of ulong to hold the 32-bit bitfield) TODO: Implement a CLS-compliant work-around or justify why not |
 dGeomSetCollideBits | Set the "collide" bitfield for the given geom. This bitfield is used by spaces to govern which geoms will interact with each other. The bitfield is guaranteed to be at least 32 bits wide. The default category and collide values for newly created geoms have all bits set. Note this is NOT CLS-compliant (due to the use of ulong to hold the 32-bit bitfield) TODO: Implement a CLS-compliant work-around or justify why not |
 dGeomSetData | Set the user-defined data pointer stored in the geom. WARNING: It is unclear from the ODE source and the documentation what the nature of user-data is. This function is here for the sake of completeness because it is part of ODE's public API, but has NOT been tested in any way. Use at own risk. |
 dGeomSetOffsetPosition | Geom Offset Overview Geom offsets allow geom objects to be offset from a body's position. This is useful for cases where an object has an offset centre of mass, or is made up out of several geoms each with their own local position. Native support for geom offsets means that the geomTransform container is now obselete. The real advantage over geomTransform is that there is a much easier interface for setting, getting, and modifying a geom's offset from its body. The elimination of geomTransform simplifies callbacks which no longer have to special case that geom class type. In terms of performance, the new code has a negligible performance difference and a memory improvement compared to using a geomTransform. Geom Offset and Bodies An offset only makes sense for geoms which are connected to bodies. It is an error to attempt to set an offset for a geom which is not connected to a body. When a geom is disconnected from a body, any offset will be automatically eliminated. Thus, the possible states a geom can be in are: * Geom * Geom on body * Geom on body, with an offset To create an offset, just call one of the geomSetOffset functions. The offset will be automatically created if it does not yet exist. Geom offsets are normally set by specifying the offset in local coordinates. An extra set of functions are provided to allow an offset to be determined by providing world coordinates and subtracting them from the current body position. These second set of functions, geomSetOffsetWorldPosition(),etc, allow the user to essentially say "keep the body where it is, and move its geom to this position in the world". Set the local offset position of a geom from its body. After this call, the geom will be at a new position determined from the body's position and the offset. The geom must be attached to a body. If the geom did not have an offset, it is automatically created. |
 dGeomSetOffsetQuaternion | Set the local offset rotation of a geom from its body. Sets the geom's rotational offset in local coordinates. After this call, the geom will be at a new position determined from the body's position and the offset. The geom must be attached to a body. If the geom did not have an offset, it is automatically created. |
 dGeomSetOffsetRotation | Set the local offset rotation matrix of a geom from its body. Sets the geom's rotational offset in local coordinates. After this call, the geom will be at a new position determined from the body's position and the offset. The geom must be attached to a body. If the geom did not have an offset, it is automatically created. |
 dGeomSetOffsetWorldPosition | Set the offset position of a geom from its body. Sets the geom's positional offset to move it to the new world coordinates. After this call, the geom will be at the world position passed in, and the offset will be the difference from the current body position. The geom must be attached to a body. If the geom did not have an offset, it is automatically created. |
 dGeomSetOffsetWorldQuaternion | Set the offset rotation of a geom from its body. Sets the geom's rotational offset to orient it to the new world rotation matrix. After this call, the geom will be at the world orientation passed in, and the offset will be the difference from the current body orientation. The geom must be attached to a body. If the geom did not have an offset, it is automatically created. |
 dGeomSetOffsetWorldRotation | Set the offset rotation of a geom from its body. Sets the geom's rotational offset to orient it to the new world rotation matrix. After this call, the geom will be at the world orientation passed in, and the offset will be the difference from the current body orientation. The geom must be attached to a body. If the geom did not have an offset, it is automatically created. |
 dGeomSetPosition | Set the position vector of a placeable geom. This function is analogous to dBodySetPosition. If the geom is attached to a body, the body's position will also be changed. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomSetQuaternion | Set the rotation of a placeable geom. This function is analogous to dBodySetQuaternion. If the geom is attached to a body, the body's rotation will also be changed. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomSetRotation | Overloaded. Set the rotation matrix of a placeable geom. This function is analogous to dBodySetRotation. If the geom is attached to a body, the body's rotation will also be changed. Calling this function on a non-placeable geom results in a runtime error in the debug build of ODE. |
 dGeomSphereGetRadius | Return the radius of the given sphere. |
 dGeomSpherePointDepth | Return the depth of the point (x,y,z) in the given sphere. Points inside the geom will have positive depth, points outside it will have negative depth, and points on the surface will have zero depth. |
 dGeomSphereSetRadius | Set the radius of the given sphere. |
 dGeomTransformGetCleanup | Get the clean-up mode of geometry transform g. If the clean-up mode is 1, then the encapsulated object will be destroyed when the geometry transform is destroyed. If the clean-up mode is 0 this does not happen. The default clean-up mode is 0. |
 dGeomTransformGetGeom | Get the geom that the geometry transform g encapsulates. |
 dGeomTransformGetInfo | Set and get the "information" mode of geometry transform g. The mode can be 0 or 1. The default mode is 0. |
 dGeomTransformSetCleanup | Set the clean-up mode of geometry transform g. If the clean-up mode is 1, then the encapsulated object will be destroyed when the geometry transform is destroyed. If the clean-up mode is 0 this does not happen. The default clean-up mode is 0. |
 dGeomTransformSetGeom | Set the geom that the geometry transform g encapsulates. The object obj must not be inserted into any space, and must not be associated with any body. If g has its clean-up mode turned on, and it already encapsulates an object, the old object will be destroyed before it is replaced with the new one. |
 dGeomTransformSetInfo | Set and get the "information" mode of geometry transform g. The mode can be 0 or 1. The default mode is 0. With mode 0, when a transform object is collided with another object (using dCollide (tx_geom,other_geom,...)), the g1 field of the dContactGeom structure is set to the geom that is encapsulated by the transform object. This value of g1 allows the caller to interrogate the type of the geom that is transformed, but it does not allow the caller to determine the position in global coordinates or the associated body, as both of these properties are used differently for encapsulated geoms. With mode 1, the g1 field of the dContactGeom structure is set to the transform object itself. This makes the object appear just like any other kind of geom, as dGeomGetBody will return the attached body, and dGeomGetPosition will return the global position. To get the actual type of the encapsulated geom in this case, dGeomTransformGetGeom must be used. |
 dGeomTriMeshClearTCCache | Clears the internal temporal coherence caches. When a geom has its collision checked with a trimesh once, data is stored inside the trimesh. With large worlds with lots of seperate objects this list could get huge. |
 dGeomTriMeshDataBuildDouble | Build Trimesh data with double precision used in vertex data. |
 dGeomTriMeshDataBuildDouble1 | Build Trimesh data with double precision used in vertex data. This function takes a normals array which is used as a trimesh-trimesh optimization. |
 dGeomTriMeshDataBuildSimple | Simple trimesh build function provided for convenience. Uses single/double precision vertices and normals depending on the current value of the dReal alias. The precision to use depends on which version of the ODE library is being used - single or double precision. Depends on whether dSINGLE or dDOUBLE is defined during ODE compilation. |
 dGeomTriMeshDataBuildSimple1 | Simple trimesh build function provided for convenience. This version takes a normals array to use for trimesh-trimesh optimization. Uses single/double precision vertices and normals depending on the current value of the dReal alias. The precision to use depends on which version of the ODE library is being used - single or double precision. Depends on whether dSINGLE or dDOUBLE is defined during ODE compilation. |
 dGeomTriMeshDataBuildSingle | Build Trimesh data with single precision used in vertex data. |
 dGeomTriMeshDataBuildSingle1 | Build Trimesh data with single precision used in vertex data. This function takes a normals array which is used as a trimesh-trimesh optimization. |
 dGeomTriMeshDataCreate | Create a dTriMeshData object which is used to store mesh data. |
 dGeomTriMeshDataDestroy | Destroy a dTriMeshData object. |
 dGeomTriMeshDataSet | In order to efficiently resolve collisions, dCollideTTL needs the positions of the colliding trimeshes in the previous timestep. This is used to calculate an estimated velocity of each colliding triangle, which is used to find the direction of impact, contact normals, etc. This requires the user to update these variables at every timestep. This update is performed outside of ODE, so it is not included in ODE itself. The code to do this looks something like this: const double *DoubleArrayPtr = Bodies[BodyIndex].TransformationMatrix->GetArray(); dGeomTriMeshDataSet( TriMeshData, TRIMESH_LAST_TRANSFORMATION, (void *) DoubleArrayPtr ); The transformation matrix is the standard 4x4 homogeneous transform matrix, and the "DoubleArray" is the standard flattened array of the 16 matrix values. |
 dGeomTriMeshEnableTC | Enable/disable the use of temporal coherence during tri-mesh collision checks. Temporal coherence can be enabled/disabled per tri-mesh instance/geom class pair, currently it works for spheres and boxes. The default for spheres and boxes is 'false'. The 'enable' param should be 1 for true, 0 for false. Temporal coherence is optional because allowing it can cause subtle efficiency problems in situations where a tri-mesh may collide with many different geoms during its lifespan. If you enable temporal coherence on a tri-mesh then these problems can be eased by intermittently calling dGeomTriMeshClearTCCache for it. |
 dGeomTriMeshGetArrayCallback | Get per object callback for specified trimesh |
 dGeomTriMeshGetCallback | Get per triangle callback for specified trimesh. |
 dGeomTriMeshGetPoint | Retrieves a position on the requested triangle and the given barycentric coordinates |
 dGeomTriMeshGetRayCallback | Get ray callback for specified trimesh. |
 dGeomTriMeshGetTriangle | Retrieves a triangle in object space. The v0, v1 and v2 arguments are optional. |
 dGeomTriMeshGetTriMeshDataID | Returns the TriMeshDataID for the specified geom. |
 dGeomTriMeshIsTCEnabled | Checks whether the use of temporal coherence during tri-mesh collision checks is enabled. Returns 1 if enabled, 0 if not enabled. |
 dGeomTriMeshSetArrayCallback | Set per object callback for specified trimesh. |
 dGeomTriMeshSetCallback | Set per triangle callback for specified trimesh. |
 dGeomTriMeshSetData | Replaces the current vertex data. |
 dGeomTriMeshSetRayCallback | Set ray callback for specified trimesh. |
 dHashSpaceCreate | Create a multi-resolution hash table space. If space is nonzero, insert the new space into that space. |
 dHashSpaceGetLevels | Get some parameters for a multi-resolution hash table space. The smallest and largest cell sizes used in the hash table will be 2^minlevel and 2^maxlevel respectively. minlevel must be less than or equal to maxlevel. The minimum and maximum levels are returned through pointers. If a pointer is zero then it is ignored and no argument is returned. |
 dHashSpaceSetLevels | Sets some parameters for a multi-resolution hash table space. The smallest and largest cell sizes used in the hash table will be 2^minlevel and 2^maxlevel respectively. minlevel must be less than or equal to maxlevel. |
 dInfiniteAABB | This function can be used as the AABB-getting function in a geometry class, if you don't want to compute tight bounds for the AABB. It returns +/- infinity in each direction. |
 dJointAddAMotorTorques | Applies torque0 about the AMotor's axis 0, torque1 about the AMotor's axis 1, and torque2 about the AMotor's axis 2. If the motor has fewer than three axes, the higher torques are ignored. |
 dJointAddHinge2Torques | Applies torque1 about the hinge2's axis 1, and torque2 about the hinge2's axis 2. This function is just a wrapper for dBodyAddTorque. |
 dJointAddHingeTorque | Applies the torque about the hinge axis. That is, it applies a torque with magnitude torque, in the direction of the hinge axis, to body 1, and with the same magnitude but in opposite direction to body 2. |
 dJointAddSliderForce | Applies the given force in the slider's direction. That is, it applies a force with magnitude force, in the direction slider's axis, to body1, and with the same magnitude but opposite direction to body2. |
 dJointAddUniversalTorques | Applies torque1 about the universal's axis 1, and torque2 about the universal's axis 2. |
 dJointAttach | Attach the joint to some new bodies. If the joint is already attached, it will be detached from the old bodies first. To attach this joint to only one body, set body1 or body2 to zero - a zero body refers to the static environment. Setting both bodies to zero puts the joint into "limbo", i.e. it will have no effect on the simulation. Some joints, like hinge-2 need to be attached to two bodies to work. |
 dJointCreateAMotor | Create a new angular motor joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateBall | Create a new ball joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateContact | Create a new contact joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. The contact joint will be initialized with the given dContact structure. |
 dJointCreateFixed | Create a new fixed joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateHinge | Create a new hinge joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateHinge2 | Create a new hinge-2 joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateLMotor | Create a new L-motor joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateNull | Create a new "null" joint. There's no discussion of this in the docs or sourcecode. The only mention is the following entry in the ODE Changelog: 10/11/01 russ * joints can now return m=0 to be "inactive". added a "null" joint to test this. This suggests a null joint is mainly useful for testing and should probably be ignored by users of the bindings. |
 dJointCreateSlider | Create a new slider joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointCreateUniversal | Create a new universal joint. The joint is initially in "limbo" (i.e. it has no effect on the simulation) because it does not connect to any bodies. The joint group ID is 0 to allocate the joint normally. If it is nonzero the joint is allocated in the given joint group. |
 dJointDestroy | Destroy a joint, disconnecting it from its attached bodies and removing it from the world. However, if the joint is a member of a group then this function has no effect - to destroy that joint the group must be emptied or destroyed. |
 dJointGetAMotorAngle | Return the current angle for axis anum. In dAMotorUser mode this is simply the value that was set with dJointSetAMotorAngle. In dAMotorEuler mode this is the corresponding euler angle. |
 dJointGetAMotorAngleRate | Return the current angle rate for axis anum. In dAMotorUser mode this is always zero, as not enough information is available. In dAMotorEuler mode this is the corresponding euler angle rate. |
 dJointGetAMotorAxis | Get the specified AMotor axis. The anum argument selects the axis to get (0,1 or 2). |
 dJointGetAMotorAxisRel | Get the relative orientation mode for the specified axis The anum argument selects the axis to get (0,1 or 2). The return value will represent one of three ``relative orientation'' modes: * 0: The axis is anchored to the global frame. * 1: The axis is anchored to the first body. * 2: The axis is anchored to the second body. |
 dJointGetAMotorMode | Get the angular motor mode. The mode parameter will be one of the following constants: dAMotorUser: The AMotor axes and joint angle settings are entirely controlled by the user. This is the default mode. dAMotorEuler: Euler angles are automatically computed. The axis a1 is also automatically computed. The AMotor axes must be set correctly when in this mode, as described below. When this mode is initially set the current relative orientations of the bodies will correspond to all euler angles at zero. |
 dJointGetAMotorNumAxes | Get the number of angular axes controlled by the AMotor. The number of axes can range from 0 (which effectively deactivates the joint) to 3. This is automatically set to 3 in dAMotorEuler mode. |
 dJointGetAMotorParam | Get limit/motor parameters for a an angular motor joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointGetBallAnchor | Method dJointGetBallAnchor Get the joint anchor point on body 1, in world coordinates. If the joint is perfectly satisfied, this will be the same as the point on body 2. |
 dJointGetBallAnchor2 | Method dJointGetBallAnchor2 Get the joint anchor point on body 2, in world coordinates. You can think of a ball and socket joint as trying to keep the result of dJointGetBallAnchor() and dJointGetBallAnchor2() the same. If the joint is perfectly satisfied, this function will return the same value as dJointGetBallAnchor to within roundoff errors. dJointGetBallAnchor2 can be used, along with dJointGetBallAnchor, to see how far the joint has come apart. |
 dJointGetBody | Return the bodies that this joint connects. If index is 0 the ``first'' body will be returned, corresponding to the body1 argument of dJointAttach. If index is 1 the ``second'' body will be returned, corresponding to the body2 argument of dJointAttach. If one of these returned body IDs is zero, the joint connects the other body to the static environment. If both body IDs are zero, the joint is in ``limbo'' and has no effect on the simulation. |
 dJointGetData | Get the joint's user-data pointer. |
 dJointGetFeedback | Get the jointfeedback structure from the joint to get information about the forces applied by each joint. The feedback information structure is defined as follows (NOTE: C# version listed here): public struct dJointFeedback { public dVector3 f1; /* force that joint applies to body 1 */ public dVector3 t1; /* torque that joint applies to body 1 */ public dVector3 f2; /* force that joint applies to body 2 */ public dVector3 t2; /* torque that joint applies to body 2 */ }; The dJointGetFeedback() function returns the current feedback structure pointer, or 0 if none is used (this is the default). TODO: Will passing 0 work or does something special have to be done? |
 dJointGetHinge2Anchor | Get the joint anchor point, in world coordinates. This returns the point on body 1. If the joint is perfectly satisfied, this will be the same as the point on body 2. |
 dJointGetHinge2Anchor2 | Get the joint anchor point, in world coordinates. This returns the point on body 2. If the joint is perfectly satisfied, this will return the same value as dJointGetHinge2Anchor. If not, this value will be slightly different. This can be used, for example, to see how far the joint has come apart. |
 dJointGetHinge2Angle1 | Get the hinge-2 angles (around axis 1 and axis 2) When the anchor or axis is set, the current position of the attached bodies is examined and that position will be the zero angle. |
 dJointGetHinge2Angle1Rate | Get the time derivative of hinge-2 angle 1 |
 dJointGetHinge2Angle2Rate | Get the time derivative of hinge-2 angle 2 |
 dJointGetHinge2Axis1 | Get hinge-2 axis 1 parameters. |
 dJointGetHinge2Axis2 | Get hinge-2 axis 2 parameters. |
 dJointGetHinge2Param | Get limit/motor parameters for a hinge-2 joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointGetHingeAnchor | Get the joint anchor point, in world coordinates. This returns the point on body 1. If the joint is perfectly satisfied, this will be the same as the point on body 2. |
 dJointGetHingeAnchor2 | Get the joint anchor point, in world coordinates. This returns the point on body 2. If the joint is perfectly satisfied, this will return the same value as dJointGetHingeAnchor. If not, this value will be slightly different. This can be used, for example, to see how far the joint has come apart. |
 dJointGetHingeAngle | Get the hinge angle of the joint. The angle is measured between the two bodies, or between the body and the static environment. The angle will be between -pi..pi. When the hinge anchor or axis is set, the current position of the attached bodies is examined and that position will be the zero angle. |
 dJointGetHingeAngleRate | Get the time derivative of the hinge angle of the joint |
 dJointGetHingeAxis | Get the hinge axis parameter for the joint. |
 dJointGetHingeParam | Get limit/motor parameters for a hinge joint |
 dJointGetSliderAxis | Get the slider axis parameter |
 dJointGetSliderParam | Get limit/motor parameters for a slider joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointGetSliderPosition | Get the slider linear position (i.e. the slider's ``extension'') When the axis is set, the current position of the attached bodies is examined and that position will be the zero position. |
 dJointGetSliderPositionRate | Get the time derivative of the slider linear position. |
 dJointGetType | Get the joint's type. The available joint types are: dJointTypeBall: A ball-and-socket joint. dJointTypeHinge: A hinge joint. dJointTypeSlider: A slider joint. dJointTypeContact: A contact joint. dJointTypeUniversal: A universal joint. dJointTypeHinge2: A hinge-2 joint. dJointTypeFixed: A fixed joint. dJointTypeAMotor: An angular motor joint. dJointTypeLMotor: An L-motor joint. |
 dJointGetUniversalAnchor | Get the joint anchor point, in world coordinates. This returns the point on body 1. If the joint is perfectly satisfied, this will be the same as the point on body 2. |
 dJointGetUniversalAnchor2 | Get the joint anchor point, in world coordinates. This returns the point on body 2. You can think of the ball and socket part of a universal joint as trying to keep the result of dJointGetBallAnchor() and dJointGetBallAnchor2() the same. If the joint is perfectly satisfied, this function will return the same value as dJointGetUniversalAnchor to within roundoff errors. dJointGetUniversalAnchor2 can be used, along with dJointGetUniversalAnchor, to see how far the joint has come apart. |
 dJointGetUniversalAngle1 |
|
 dJointGetUniversalAngle1Rate |
|
 dJointGetUniversalAngle2 |
|
 dJointGetUniversalAngle2Rate |
|
 dJointGetUniversalAxis1 | Get parameters for universal joint axis 1 |
 dJointGetUniversalAxis2 | Get parameters for universal joint axis 2 |
 dJointGetUniversalParam | Get limit/motor parameters for a universal joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointGroupCreate | Create a joint group. NOTE: The max_size argument is no longer used and should be set to 0. It is kept for backwards compatibility. |
 dJointGroupDestroy | Destroy a joint group. All joints in the joint group will be destroyed. |
 dJointGroupEmpty | Empty a joint group. All joints in the joint group will be destroyed, but the joint group itself will not be destroyed. |
 dJointSetAMotorAngle | Tell the AMotor what the current angle is along axis anum. This function should only be called in dAMotorUser mode, because in this mode the AMotor has no other way of knowing the joint angles. The angle information is needed if stops have been set along the axis, but it is not needed for axis motors. |
 dJointSetAMotorAxis | Set the AMotor axes. The anum argument selects the axis to change (0,1 or 2). Each axis can have one of three ``relative orientation'' modes, selected by rel: * 0: The axis is anchored to the global frame. * 1: The axis is anchored to the first body. * 2: The axis is anchored to the second body. The axis vector (x,y,z) is always specified in global coordinates regardless of the setting of rel. For dAMotorEuler mode: * Only axes 0 and 2 need to be set. Axis 1 will be determined automatically at each time step. * Axes 0 and 2 must be perpendicular to each other. * Axis 0 must be anchored to the first body, axis 2 must be anchored to the second body. |
 dJointSetAMotorMode | Set the angular motor mode. The mode parameter must be one of the following constants: dAMotorUser: The AMotor axes and joint angle settings are entirely controlled by the user. This is the default mode. dAMotorEuler: Euler angles are automatically computed. The axis a1 is also automatically computed. The AMotor axes must be set correctly when in this mode, as described below. When this mode is initially set the current relative orientations of the bodies will correspond to all euler angles at zero. |
 dJointSetAMotorNumAxes | Set the number of angular axes that will be controlled by the AMotor. The argument num can range from 0 (which effectively deactivates the joint) to 3. This is automatically set to 3 in dAMotorEuler mode. |
 dJointSetAMotorParam | Set limit/motor parameters for a an angular motor joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointSetBallAnchor | Method dJointSetBallAnchor Set the joint anchor point. The joint will try to keep this point on each body together. The input is specified in world coordinates. |
 dJointSetBallAnchor2 | Method dJointSetBallAnchor2 Set the joint anchor point. The joint will try to keep this point on each body together. The input is specified in world coordinates. |
 dJointSetData | Set the joint's user-data pointer. |
 dJointSetFeedback | Pass a dJointFeedback structure to the joint to collect information about the forces applied by each joint. Notes from the ODE docs: During the world time step, the forces that are applied by each joint are computed. These forces are added directly to the joined bodies, and the user normally has no way of telling which joint contributed how much force. If this information is desired then the user can allocate a dJointFeedback structure and pass its pointer to the dJointSetFeedback() function. The feedback information structure is defined as follows (NOTE: C# version listed here): public struct dJointFeedback { public dVector3 f1; /* force that joint applies to body 1 */ public dVector3 t1; /* torque that joint applies to body 1 */ public dVector3 f2; /* force that joint applies to body 2 */ public dVector3 t2; /* torque that joint applies to body 2 */ }; During the time step any feedback structures that are attached to joints will be filled in with the joint's force and torque information. The dJointGetFeedback() function returns the current feedback structure pointer, or 0 if none is used (this is the default). dJointSetFeedback() can be passed 0 to disable feedback for that joint. TODO: Will passing 0 work? Seems as if something else needs to be passed here Now for some API design notes. It might seem strange to require that users perform the allocation of these structures. Why not just store the data statically in each joint? The reason is that not all users will use the feedback information, and even when it is used not all joints will need it. It will waste memory to store it statically, especially as this structure could grow to store a lot of extra information in the future. Why not have ODE allocate the structure itself, at the user's request? The reason is that contact joints (which are created and destroyed every time step) would require a lot of time to be spent in memory allocation if feedback is required. Letting the user do the allocation means that a better allocation strategy can be provided, e.g simply allocating them out of a fixed array. The alternative to this API is to have a joint-force callback. This would work of course, but it has a few problems. First, callbacks tend to pollute APIs and sometimes require the user to go through unnatural contortions to get the data to the right place. Second, this would expose ODE to being changed in the middle of a step (which would have bad consequences), and there would have to be some kind of guard against this or a debugging check for it - which would complicate things. |
 dJointSetFixed | Call this on the fixed joint after it has been attached to remember the current desired relative offset and desired relative rotation between the bodies. |
 dJointSetHinge2Anchor | Set hinge-2 anchor parameters |
 dJointSetHinge2Axis1 | Set hinge-2 axis 1 parameters Axis 1 and axis 2 must not lie on the same line |
 dJointSetHinge2Axis2 | Set hinge-2 axis 2 parameters Axis 1 and axis 2 must not lie on the same line |
 dJointSetHinge2Param | Set limit/motor parameters for a hinge-2 joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointSetHingeAnchor | Set hinge anchor parameters |
 dJointSetHingeAnchorDelta | Set hinge anchor parameters |
 dJointSetHingeAxis | Set hinge axis parameters |
 dJointSetHingeParam | Set limit/motor parameters for a hinge joint |
 dJointSetSliderAxis | Set the slider axis parameter. |
 dJointSetSliderAxisDelta | Set the slider axis delta. |
 dJointSetSliderParam | Set limit/motor parameters for a slider joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dJointSetUniversalAnchor | Set universal joint anchor parameters. |
 dJointSetUniversalAxis1 | Set universal joint axis 1 parameters Axis 1 and axis 2 should be perpendicular to each other. |
 dJointSetUniversalAxis2 | Set universal joint axis 2 parameters Axis 1 and axis 2 should be perpendicular to each other. |
 dJointSetUniversalParam | Set limit/motor parameters for a universal joint See http://ode.org/ode-latest-userguide.html#sec_7_5_1 for details |
 dMassAdd | Add the mass b to the mass a. |
 dMassAdjust | Given mass parameters for some object, adjust them so the total mass is now newmass |
 dMassRotate | Overloaded. Given mass parameters for some object, adjust them to represent the object rotated by R relative to the body frame. |
 dMassSetBox | Set the mass parameters to represent a box of the given dimensions and density, with the center of mass at (0,0,0) relative to the body. |
 dMassSetBoxTotal | Set the mass parameters to represent a box of the given dimensions and total mass, with the center of mass at (0,0,0) relative to the body. |
 dMassSetCapsule | Set the mass parameters to represent a capsule of the given parameters and density, with the center of mass at (0,0,0) relative to the body. |
 dMassSetCapsuleTotal | Set the mass parameters to represent a capsule of the given parameters and total mass, with the center of mass at (0,0,0) relative to the body. |
 dMassSetCylinder | Set the mass parameters to represent a flat-ended cylinder of the given parameters and density, with the center of mass at (0,0,0) relative to the body. |
 dMassSetCylinderTotal | Set the mass parameters to represent a flat-ended cylinder of the given parameters and total mass, with the center of mass at (0,0,0) relative to the body. |
 dMassSetParameters | Set the mass parameters to the given values. |
 dMassSetSphere | Set the mass parameters to represent a sphere of the given radius and density, with the center of mass at (0,0,0) relative to the body. |
 dMassSetSphereTotal | Set the mass parameters to represent a sphere of the given total mass and radius, with the center of mass at (0,0,0) relative to the body. |
 dMassSetZero | Set all the mass parameters to zero |
 dMassTranslate | Given mass parameters for some object, adjust them to represent the object displaced by (x,y,z) relative to the body frame. |
 dQFromAxisAndAngle | Compute q as a rotation of angle radians along the axis (ax,ay,az). |
 dQMultiply0 | Set qa = qb*qc. This is that same as qa = rotation qc followed by rotation qb. The 0/1/2 versions are analogous to the multiply functions, i.e. 1 uses the inverse of qb, and 2 uses the inverse of qc. Option 3 uses the inverse of both. |
 dQMultiply1 | Set qa = qb*qc. This is that same as qa = rotation qc followed by rotation qb. The 0/1/2 versions are analogous to the multiply functions, i.e. 1 uses the inverse of qb, and 2 uses the inverse of qc. Option 3 uses the inverse of both. |
 dQMultiply2 | Set qa = qb*qc. This is that same as qa = rotation qc followed by rotation qb. The 0/1/2 versions are analogous to the multiply functions, i.e. 1 uses the inverse of qb, and 2 uses the inverse of qc. Option 3 uses the inverse of both. |
 dQMultiply3 | Set qa = qb*qc. This is that same as qa = rotation qc followed by rotation qb. The 0/1/2 versions are analogous to the multiply functions, i.e. 1 uses the inverse of qb, and 2 uses the inverse of qc. Option 3 uses the inverse of both. |
 dQSetIdentity | Set q to the identity rotation (i.e. no rotation). |
 dQtoR | Convert quaternion q to rotation matrix R. |
 dQuadTreeSpaceCreate | Creates a quadtree space. If space is nonzero, insert the new space into that space. Center and Extents define the size of the root block. Depth sets the depth of the tree - the number of blocks that are created is 4^Depth |
 dRFrom2Axes | Compute the rotation matrix R from the two vectors `a' (ax,ay,az) and `b' (bx,by,bz). `a' and `b' are the desired x and y axes of the rotated coordinate system. If necessary, `a' and `b' will be made unit length, and `b' will be projected so that it is perpendicular to `a'. The desired z axis is the cross product of `a' and `b'. |
 dRFromAxisAndAngle | Compute the rotation matrix R as a rotation of angle radians along the axis (ax,ay,az). |
 dRFromEulerAngles | Compute the rotation matrix R from the three Euler rotation angles. |
 dRFromZAxis | Overloaded. TODO: Document Me |
 dRSetIdentity | Set R to the identity matrix (i.e. no rotation). |
 dRtoQ | Convert rotation matrix R to quaternion q. |
 dSimpleSpaceCreate | Create a simple space. If space is nonzero, insert the new space into that space. |
 dSpaceAdd | Add a geom to a space. This does nothing if the geom is already in the space. This function can be called automatically if a space argument is given to a geom creation function. |
 dSpaceClean | Cleans the space |
 dSpaceCollide | This determines which pairs of geoms in a space may potentially intersect, and calls the callback function with each candidate pair. The callback function is of type dNearCallback, which is defined as: typedef void dNearCallback (void *data, dGeomID o1, dGeomID o2); The data argument is passed from dSpaceCollide directly to the callback function. Its meaning is user defined. The o1 and o2 arguments are the geoms that may be near each other. The callback function can call dCollide on o1 and o2 to generate contact points between each pair. Then these contact points may be added to the simulation as contact joints. The user's callback function can of course chose not to call dCollide for any pair, e.g. if the user decides that those pairs should not interact. Other spaces that are contained within the colliding space are not treated specially, i.e. they are not recursed into. The callback function may be passed these contained spaces as one or both geom arguments. dSpaceCollide() is guaranteed to pass all intersecting geom pairs to the callback function, but it may also make mistakes and pass non-intersecting pairs. The number of mistaken calls depends on the internal algorithms used by the space. Thus you should not expect that dCollide will return contacts for every pair passed to the callback. |
 dSpaceCollide2 | This function is similar to dSpaceCollide, except that it is passed two geoms (or spaces) as arguments. It calls the callback for all potentially intersecting pairs that contain one geom from o1 and one geom from o2. The exact behavior depends on the types of o1 and o2: If one argument is a non-space geom and the other is a space, the callback is called with all potential intersections between the geom and the objects in the space. If both o1 and o2 are spaces then this calls the callback for all potentially intersecting pairs that contain one geom from o1 and one geom from o2. The algorithm that is used depends on what kinds of spaces are being collided. If no optimized algorithm can be selected then this function will resort to one of the following two strategies: 1. All the geoms in o1 are tested one-by-one against o2. 2. All the geoms in o2 are tested one-by-one against o1. The strategy used may depend on a number of rules, but in general the space with less objects has its geoms examined one-by-one. - If both arguments are the same space, this is equivalent to calling dSpaceCollide on that space. - If both arguments are non-space geoms, this simply calls the callback once with these arguments. If this function is given a space and an geom X in that same space, this case is not treated specially. In this case the callback will always be called with the pair (X,X), because an objects always intersects with itself. The user may either test for this case and ignore it, or just pass the pair (X,X) to dCollide (which will be guaranteed to return 0). |
 dSpaceDestroy | This destroys a space. It functions exactly like dGeomDestroy except that it takes a dSpaceID argument. When a space is destroyed, if its cleanup mode is 1 (the default) then all the geoms in that space are automatically destroyed as well. |
 dSpaceGetCleanup | Get the clean-up mode of the space. |
 dSpaceGetGeom | Return the i'th geom contained within the space. i must range from 0 to dSpaceGetNumGeoms()-1. If any change is made to the space (including adding and deleting geoms) then no guarantee can be made about how the index number of any particular geom will change. Thus no space changes should be made while enumerating the geoms. This function is guaranteed to be fastest when the geoms are accessed in the order 0,1,2,etc. Other non-sequential orders may result in slower access, depending on the internal implementation. |
 dSpaceGetNumGeoms | Return the number of geoms contained within a space. |
 dSpaceQuery | Return 1 if the given geom is in the given space, or return 0 if it is not. |
 dSpaceRemove | Remove a geom from a space. This does nothing if the geom is not actually in the space. This function is called automatically by dGeomDestroy if the geom is in a space. |
 dSpaceSetCleanup | Set the clean-up mode of the space. If the clean-up mode is 1, then the contained geoms will be destroyed when the space is destroyed. If the clean-up mode is 0 this does not happen. The default clean-up mode for new spaces is 1. |
 dWorldCreate | Create a new, empty world and return its ID number. |
 dWorldDestroy | Destroy a world and everything in it. This includes all bodies, and all joints that are not part of a joint group. Joints that are part of a joint group will be deactivated, and can be destroyed by calling, for example, dJointGroupEmpty. |
 dWorldGetAutoDisableAngularThreshold | Get the current auto-disable angular threshold for newly created objects |
 dWorldGetAutoDisableFlag | Get the current auto-disable flag for newly created bodies. |
 dWorldGetAutoDisableLinearThreshold | Get the current auto-disable linear threshold for newly created bodies. |
 dWorldGetAutoDisableSteps | Get the current auto-disable steps for newly created bodies |
 dWorldGetAutoDisableTime | Get the current auto-disable time for newly created bodies. |
 dWorldGetAutoEnableDepthSF1 | Get the AutoEnableDepth parameter used by the StepFast1 algorithm. |
 dWorldGetCFM | Get the global CFM (constraint force mixing) value. Typical values are in the range 10^-9 -- 1. The default is 10-5 if single precision is being used, or 10^-10 if double precision is being used. |
 dWorldGetContactMaxCorrectingVel | Get the maximum correcting velocity that contacts are allowed to generate. The default value is infinity (i.e. no limit). |
 dWorldGetContactSurfaceLayer | Get the depth of the surface layer around all geometry objects. The default value is zero. |
 dWorldGetERP | Get the global ERP value, which controls how much error correction is performed in each time step. Typical values are in the range 0.1--0.8. The default is 0.2. |
 dWorldGetGravity | Get the world's global gravity vector. The units are m/s/s (meter/second/second). |
 dWorldGetQuickStepNumIterations | Get the number of iterations that the QuickStep method performs per step. The default is 20 iterations. |
 dWorldGetQuickStepW | Get the QuickStep SOR over-relaxation parameter |
 dWorldImpulseToForce | Convert linear/angular impulse to a rigid body to a force/torque vector. If you want to apply a linear or angular impulse to a rigid body, instead of a force or a torque, then you can use this function to convert the desired impulse into a force/torque vector before calling the dBodyAdd... function. This function is given the desired impulse as (ix,iy,iz) and puts the force vector in force. The current algorithm simply scales the impulse by 1/stepsize, where stepsize is the step size for the next step that will be taken. |
 dWorldQuickStep | Step the world. This uses an iterative method that takes time on the order of m*N and memory on the order of m, where m is the total number of constraint rows and N is the number of iterations. For large systems this is a lot faster than dWorldStep, but it is less accurate. |
 dWorldSetAutoDisableAngularThreshold | Set the default auto-disable angular threshold for newly created bodies. The default parameter is: AutoDisableAngularThreshold = 0.01 |
 dWorldSetAutoDisableFlag | Set the default auto-disable flag for newly created bodies. The default parameter is: AutoDisableFlag = disabled |
 dWorldSetAutoDisableLinearThreshold | Set the default auto-disable linear threshold for newly created bodies. The default parameter is: AutoDisableLinearThreshold = 0.01 |
 dWorldSetAutoDisableSteps | Set the default auto-disable steps for newly created bodies. The default parameter is: AutoDisableSteps = 10 |
 dWorldSetAutoDisableTime | Set the default auto-disable time for newly created bodies. The default parameter is: AutoDisableTime = 0 |
 dWorldSetAutoEnableDepthSF1 | Set the AutoEnableDepth parameter used by the StepFast1 algorithm. |
 dWorldSetCFM | Set the global CFM (constraint force mixing) value. Typical values are in the range 10^-9 -- 1. The default is 10^-5 if single precision is being used, or 10^-10 if double precision is being used. |
 dWorldSetContactMaxCorrectingVel | Set maximum correcting velocity that contacts are allowed to generate. The default value is infinity (i.e. no limit). Reducing this value can help prevent "popping" of deeply embedded objects. |
 dWorldSetContactSurfaceLayer | Set the depth of the surface layer around all geometry objects. Contacts are allowed to sink into the surface layer up to the given depth before coming to rest. The default value is zero. Increasing this to some small value (e.g. 0.001) can help prevent jittering problems due to contacts being repeatedly made and broken. |
 dWorldSetERP | Set the global ERP (Error Reduction Parameter) value, which controls how much error correction is performed in each time step. Typical values are in the range 0.1--0.8. The default is 0.2. |
 dWorldSetGravity | Set the world's global gravity vector. The units are m/s/s (meters/second/second), so Earth's gravity vector would be (0,0,-9.81), assuming that +z is up. The default is no gravity, i.e. (0,0,0). |
 dWorldSetQuickStepNumIterations | Set the number of iterations that the QuickStep method performs per step. More iterations will give a more accurate solution, but will take longer to compute. The default is 20 iterations. |
 dWorldSetQuickStepW | Set the QuickStep SOR over-relaxation parameter |
 dWorldStep | Step the world. This uses a "big matrix" method that takes time on the order of m^3 and memory on the order of m^2, where m is the total number of constraint rows. For large systems this will use a lot of memory and can be very slow, but this is currently the most accurate method. |
 dWorldStepFast1 | Step the world by stepsize seconds using the StepFast1 algorithm. The number of iterations to perform is given by maxiterations. NOTE: The StepFast algorithm has been superseded by the QuickStep algorithm: see the dWorldQuickStep function. |
 dWtoDQ | Given an existing orientation q and an angular velocity vector w, return in dq the resulting dq/dt. |