Tao.Ode SDK Documentation

Ode Members

Ode overview

Public Static (Shared) Fields

dInfinity Infinity. The maximum value of the current data type for dReal.
dMaxUserClassesthe maximum number of user classes that are supported

Public Static (Shared) Methods

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.
dBodySetRotationOverloaded. 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.
dGeomRayGetParamsOverloaded. 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.
dGeomSetRotationOverloaded. 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
dMassRotateOverloaded. 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.
dRFromZAxisOverloaded. 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.

Public Instance Methods

Equals (inherited from Object) 
GetHashCode (inherited from Object) 
GetType (inherited from Object) 
ToString (inherited from Object) 

See Also

Ode Class | Tao.Ode Namespace