Up  

Module Ode.LowLevel

module LowLevel: sig .. end

Opaque types of ODE objects.

type dWorldID 
type dSpaceID 
type dBodyID 
type 'a dGeomID 
type dJointID 
type dJointGroupID 
type dMass 
type dVector3 = {
   x : float;
   y : float;
   z : float;
   w : float;
}

Note: These structures are binary-compatible with the ODE definitions, provided that the ODE library was compiled with dDOUBLE. Otherwise the OCaml datas are copied to the appropriate C type.

type dVector4 = dVector3 
type dMatrix3 = {
   r11 : float;
   r12 : float;
   r13 : float;
   r14 : float;
   r21 : float;
   r22 : float;
   r23 : float;
   r24 : float;
   r31 : float;
   r32 : float;
   r33 : float;
   r34 : float;
} 
type dMatrix4 = {
   s11 : float;
   s12 : float;
   s13 : float;
   s14 : float;
   s21 : float;
   s22 : float;
   s23 : float;
   s24 : float;
   s31 : float;
   s32 : float;
   s33 : float;
   s34 : float;
   s41 : float;
   s42 : float;
   s43 : float;
   s44 : float;
} 
type dMatrix6 = {
   t11 : float;
   t12 : float;
   t13 : float;
   t14 : float;
   t15 : float;
   t16 : float;
   t17 : float;
   t18 : float;
   t21 : float;
   t22 : float;
   t23 : float;
   t24 : float;
   t25 : float;
   t26 : float;
   t27 : float;
   t28 : float;
   t31 : float;
   t32 : float;
   t33 : float;
   t34 : float;
   t35 : float;
   t36 : float;
   t37 : float;
   t38 : float;
   t41 : float;
   t42 : float;
   t43 : float;
   t44 : float;
   t45 : float;
   t46 : float;
   t47 : float;
   t48 : float;
   t51 : float;
   t52 : float;
   t53 : float;
   t54 : float;
   t55 : float;
   t56 : float;
   t57 : float;
   t58 : float;
   t61 : float;
   t62 : float;
   t63 : float;
   t64 : float;
   t65 : float;
   t66 : float;
   t67 : float;
   t68 : float;
} 
type dQuaternion = {
   q1 : float;
   q2 : float;
   q3 : float;
   q4 : float;
} 
type ('a, 'b) dContactGeom = {
   cg_pos : dVector3;
   cg_normal : dVector3;
   cg_depth : float;
   cg_g1 : 'a dGeomID;
   cg_g2 : 'b dGeomID;
}

Contact points.

type ('a, 'b) dContact = {
   c_surface : dSurfaceParameters;
   c_geom : ('a, 'b) dContactGeom;
   c_fdir1 : dVector3;
}

Contact structure.

type dSurfaceParameters = {
   sp_mode : [ `dContactApprox1
| `dContactApprox1_1
| `dContactApprox1_2
| `dContactBounce
| `dContactFDir1
| `dContactMotion1
| `dContactMotion2
| `dContactMu2
| `dContactSlip1
| `dContactSlip2
| `dContactSoftCFM
| `dContactSoftERP ] list;
   sp_mu : float;
   sp_mu2 : float;
   sp_bounce : float;
   sp_bounce_vel : float;
   sp_soft_erp : float;
   sp_soft_cfm : float;
   sp_motion1 : float;
   sp_motion2 : float;
   sp_slip1 : float;
   sp_slip2 : float;
} 
val surf_param_zero : dSurfaceParameters
val get_surface : mu:float ->
       ?mu2:float ->
       ?bounce:float ->
       ?bounce_vel:float ->
       ?soft_erp:float ->
       ?soft_cfm:float ->
       ?motion1:float ->
       ?motion2:float ->
       ?slip1:float -> ?slip2:float -> unit -> dSurfaceParameters
type surface_parameter =
| Mu2 of float
| Bounce of float
| BounceVel of float
| SoftERP of float
| SoftCFM of float
| Motion1 of float
| Motion2 of float
| Slip1 of float
| Slip2 of float 
val surface_param : mu:float ->
       surface_parameter list -> dSurfaceParameters
type joint_type =
| JointTypeNone
| JointTypeBall
| JointTypeHinge
| JointTypeSlider
| JointTypeContact
| JointTypeUniversal
| JointTypeHinge2
| JointTypeFixed
| JointTypeNull
| JointTypeAMotor
| JointTypeLMotor
| JointTypePlane2D
| JointTypePR 
type dJointParam =
| DParamLoStop
| DParamHiStop
| DParamVel
| DParamFMax
| DParamFudgeFactor
| DParamBounce
| DParamCFM
| DParamStopERP
| DParamStopCFM
| DParamSuspensionERP
| DParamSuspensionCFM
| DParamERP
| DParamLoStop2
| DParamHiStop2
| DParamVel2
| DParamFMax2
| DParamFudgeFactor2
| DParamBounce2
| DParamCFM2
| DParamStopERP2
| DParamStopCFM2
| DParamSuspensionERP2
| DParamSuspensionCFM2
| DParamERP2
| DParamLoStop3
| DParamHiStop3
| DParamVel3
| DParamFMax3
| DParamFudgeFactor3
| DParamBounce3
| DParamCFM3
| DParamStopERP3
| DParamStopCFM3
| DParamSuspensionERP3
| DParamSuspensionCFM3
| DParamERP3
| DParamGroup 
val dGetInfinity : unit -> float
val dInfinity : float
val dInitODE : unit -> unit
val dCloseODE : unit -> unit
type dInitODEFlags =
| DInitFlagManualThreadCleanup 
val dInitODE2 : initFlags:dInitODEFlags list -> unit

World

val dWorldCreate : unit -> dWorldID
val dWorldDestroy : dWorldID -> unit
val dWorldSetGravity : dWorldID -> x:float -> y:float -> z:float -> unit
val dWorldGetGravity : dWorldID -> dVector3
val dWorldSetERP : dWorldID -> erp:float -> unit
val dWorldGetERP : dWorldID -> float
val dWorldSetCFM : dWorldID -> cfm:float -> unit
val dWorldGetCFM : dWorldID -> float
val dWorldStep : dWorldID -> float -> unit
val dWorldQuickStep : dWorldID -> float -> unit
val dWorldStepFast1 : dWorldID -> stepsize:float -> maxiterations:int -> unit
val dWorldSetAutoEnableDepthSF1 : dWorldID -> int -> unit
val dWorldGetAutoEnableDepthSF1 : dWorldID -> int
val dWorldSetQuickStepNumIterations : dWorldID -> num:int -> unit
val dWorldGetQuickStepNumIterations : dWorldID -> int
val dWorldSetContactSurfaceLayer : dWorldID -> depth:float -> unit
val dWorldGetContactSurfaceLayer : dWorldID -> float
val dWorldSetAutoDisableLinearThreshold : dWorldID -> linear_threshold:float -> unit
val dWorldGetAutoDisableLinearThreshold : dWorldID -> float
val dWorldSetAutoDisableAngularThreshold : dWorldID -> angular_threshold:float -> unit
val dWorldGetAutoDisableAngularThreshold : dWorldID -> float
val dWorldSetAutoDisableAverageSamplesCount : dWorldID -> average_samples_count:int -> unit
val dWorldGetAutoDisableAverageSamplesCount : dWorldID -> int
val dWorldSetAutoDisableSteps : dWorldID -> steps:int -> unit
val dWorldGetAutoDisableSteps : dWorldID -> int
val dWorldSetAutoDisableTime : dWorldID -> time:float -> unit
val dWorldGetAutoDisableTime : dWorldID -> float
val dWorldSetAutoDisableFlag : dWorldID -> do_auto_disable:bool -> unit
val dWorldGetAutoDisableFlag : dWorldID -> bool
val dWorldSetQuickStepW : dWorldID -> over_relaxation:float -> unit
val dWorldGetQuickStepW : dWorldID -> float
val dWorldSetContactMaxCorrectingVel : dWorldID -> vel:float -> unit
val dWorldGetContactMaxCorrectingVel : dWorldID -> float

Bodies

val dBodyCreate : dWorldID -> dBodyID
val dBodyDestroy : dBodyID -> unit
val dBodyGetWorld : dBodyID -> dWorldID
val dBodySetPosition : dBodyID -> x:float -> y:float -> z:float -> unit
val dBodySetRotation : dBodyID -> dMatrix3 -> unit
val dBodySetQuaternion : dBodyID -> dQuaternion -> unit
val dBodySetLinearVel : dBodyID -> x:float -> y:float -> z:float -> unit
val dBodySetAngularVel : dBodyID -> x:float -> y:float -> z:float -> unit
val dBodyGetPosition : dBodyID -> dVector3
val dBodyGetRotation : dBodyID -> dMatrix3
val dBodyGetQuaternion : dBodyID -> dQuaternion
val dBodyGetLinearVel : dBodyID -> dVector3
val dBodyGetAngularVel : dBodyID -> dVector3
val dBodySetMass : dBodyID -> dMass -> unit
val dBodyGetMass : dBodyID -> dMass
val dBodyAddForce : dBodyID -> fx:float -> fy:float -> fz:float -> unit
val dBodyAddTorque : dBodyID -> fx:float -> fy:float -> fz:float -> unit
val dBodyAddRelForce : dBodyID -> fx:float -> fy:float -> fz:float -> unit
val dBodyAddRelTorque : dBodyID -> fx:float -> fy:float -> fz:float -> unit
val dBodyAddForceAtPos : dBodyID ->
       fx:float -> fy:float -> fz:float -> px:float -> py:float -> pz:float -> unit
val dBodyAddForceAtRelPos : dBodyID ->
       fx:float -> fy:float -> fz:float -> px:float -> py:float -> pz:float -> unit
val dBodyAddRelForceAtPos : dBodyID ->
       fx:float -> fy:float -> fz:float -> px:float -> py:float -> pz:float -> unit
val dBodyAddRelForceAtRelPos : dBodyID ->
       fx:float -> fy:float -> fz:float -> px:float -> py:float -> pz:float -> unit
val dBodySetForce : dBodyID -> x:float -> y:float -> z:float -> unit
val dBodySetTorque : dBodyID -> x:float -> y:float -> z:float -> unit
val dBodyGetForce : dBodyID -> dVector3
val dBodyGetTorque : dBodyID -> dVector3
val dBodyGetRelPointPos : dBodyID ->
       px:float -> py:float -> pz:float -> dVector3
val dBodyGetPosRelPoint : dBodyID ->
       px:float -> py:float -> pz:float -> dVector3
val dBodyGetRelPointVel : dBodyID ->
       px:float -> py:float -> pz:float -> dVector3
val dBodyGetPointVel : dBodyID ->
       px:float -> py:float -> pz:float -> dVector3
val dBodyVectorToWorld : dBodyID ->
       px:float -> py:float -> pz:float -> dVector3
val dBodyVectorFromWorld : dBodyID ->
       px:float -> py:float -> pz:float -> dVector3
val dBodyEnable : dBodyID -> unit
val dBodyDisable : dBodyID -> unit
val dBodyIsEnabled : dBodyID -> bool
val dBodySetAutoDisableFlag : dBodyID -> bool -> unit
val dBodyGetAutoDisableFlag : dBodyID -> bool
val dBodySetAutoDisableSteps : dBodyID -> steps:int -> unit
val dBodyGetAutoDisableSteps : dBodyID -> int
val dBodySetAutoDisableTime : dBodyID -> time:float -> unit
val dBodyGetAutoDisableTime : dBodyID -> float
val dAreConnected : a:dBodyID -> b:dBodyID -> bool
val dAreConnectedExcluding : a:dBodyID ->
       b:dBodyID -> joint_type -> bool
val dBodySetGravityMode : dBodyID -> mode:bool -> unit
val dBodyGetGravityMode : dBodyID -> bool
val dBodySetFiniteRotationMode : dBodyID -> mode:bool -> unit
val dBodyGetFiniteRotationMode : dBodyID -> bool
val dBodySetFiniteRotationAxis : dBodyID -> x:float -> y:float -> z:float -> unit
val dBodyGetFiniteRotationAxis : dBodyID -> dVector3
val dBodySetAutoDisableLinearThreshold : dBodyID -> linear_average_threshold:float -> unit
val dBodyGetAutoDisableLinearThresholda : dBodyID -> float
val dBodySetAutoDisableAngularThreshold : dBodyID -> angular_average_threshold:float -> unit
val dBodyGetAutoDisableAngularThreshold : dBodyID -> float
val dBodySetAutoDisableAverageSamplesCount : dBodyID -> average_samples_count:int -> unit
val dBodyGetAutoDisableAverageSamplesCount : dBodyID -> int
val dBodySetData : dBodyID -> int -> unit
val dBodyGetData : dBodyID -> int

you can use these functions for example to associate user data to a body:

  let body_data_tbl = Hashtbl.create 16
  let dBodySetData =
    let body_data_count = ref 0 in
    fun body ~data ->
      let i = !body_data_count in
      incr body_data_count;
      Hashtbl.add body_data_tbl i data;
      dBodySetData body i;
  ;;
  let dBodyGetData body = (Hashtbl.find body_data_tbl (dBodyGetData body))

Joints

val dJointCreateBall : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateHinge : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateSlider : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateContact : dWorldID ->
       dJointGroupID option ->
       ('a, 'b) dContact -> dJointID
val dJointCreateUniversal : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateHinge2 : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateFixed : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateAMotor : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreateLMotor : dWorldID ->
       dJointGroupID option -> dJointID
val dJointCreatePlane2D : dWorldID ->
       dJointGroupID option -> dJointID
val dJointDestroy : dJointID -> unit
val dJointGroupCreate : unit -> dJointGroupID
val dJointGroupDestroy : dJointGroupID -> unit
val dJointGroupEmpty : dJointGroupID -> unit
val dJointAttach : dJointID ->
       dBodyID option -> dBodyID option -> unit
val dJointSetSliderAxis : dJointID -> x:float -> y:float -> z:float -> unit
val dJointGetSliderAxis : dJointID -> dVector3
val dJointGetSliderPosition : dJointID -> float
val dJointGetSliderPositionRate : dJointID -> float
val dJointSetHingeParam : dJointID -> dJointParam -> float -> unit
val dJointSetSliderParam : dJointID -> dJointParam -> float -> unit
val dJointSetHinge2Param : dJointID -> dJointParam -> float -> unit
val dJointSetUniversalParam : dJointID -> dJointParam -> float -> unit
val dJointSetAMotorParam : dJointID -> dJointParam -> float -> unit
val dJointSetLMotorParam : dJointID -> dJointParam -> float -> unit
val dJointGetHingeParam : dJointID -> dJointParam -> float
val dJointGetSliderParam : dJointID -> dJointParam -> float
val dJointGetHinge2Param : dJointID -> dJointParam -> float
val dJointGetUniversalParam : dJointID -> dJointParam -> float
val dJointGetAMotorParam : dJointID -> dJointParam -> float
val dJointGetLMotorParam : dJointID -> dJointParam -> float
val dJointSetBallAnchor : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetBallAnchor2 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetHingeAnchor : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetHingeAnchorDelta : dJointID ->
       x:float -> y:float -> z:float -> ax:float -> ay:float -> az:float -> unit
val dJointSetHingeAxis : dJointID -> x:float -> y:float -> z:float -> unit
val dJointAddHingeTorque : dJointID -> torque:float -> unit
val dJointSetSliderAxisDelta : dJointID ->
       x:float -> y:float -> z:float -> ax:float -> ay:float -> az:float -> unit
val dJointAddSliderForce : dJointID -> force:float -> unit
val dJointSetHinge2Anchor : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetHinge2Axis1 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetHinge2Axis2 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointAddHinge2Torques : dJointID -> torque1:float -> torque2:float -> unit
val dJointSetUniversalAnchor : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetUniversalAxis1 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetUniversalAxis2 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointAddUniversalTorques : dJointID -> torque1:float -> torque2:float -> unit
val dJointSetPRAnchor : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetPRAxis1 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetPRAxis2 : dJointID -> x:float -> y:float -> z:float -> unit
val dJointSetPRParam : dJointID -> parameter:int -> value:float -> unit
val dJointAddPRTorque : dJointID -> torque:float -> unit
val dJointSetFixed : dJointID -> unit
val dJointSetAMotorNumAxes : dJointID -> num:int -> unit
val dJointSetAMotorAxis : dJointID ->
       anum:int -> rel:int -> x:float -> y:float -> z:float -> unit
val dJointSetAMotorAngle : dJointID -> anum:int -> angle:float -> unit
val dJointSetAMotorMode : dJointID -> mode:int -> unit
val dJointAddAMotorTorques : dJointID ->
       torque1:float -> torque2:float -> torque3:float -> unit
val dJointSetLMotorNumAxes : dJointID -> num:int -> unit
val dJointSetLMotorAxis : dJointID ->
       anum:int -> rel:int -> x:float -> y:float -> z:float -> unit
val dJointSetPlane2DXParam : dJointID -> dJointParam -> float -> unit
val dJointSetPlane2DYParam : dJointID -> dJointParam -> float -> unit
val dJointSetPlane2DAngleParam : dJointID -> dJointParam -> float -> unit
val dJointGetBallAnchor : dJointID -> dVector3
val dJointGetBallAnchor2 : dJointID -> dVector3
val dJointGetHingeAnchor : dJointID -> dVector3
val dJointGetHingeAnchor2 : dJointID -> dVector3
val dJointGetHingeAxis : dJointID -> dVector3
val dJointGetHingeAngle : dJointID -> float
val dJointGetHingeAngleRate : dJointID -> float
val dJointGetHinge2Anchor : dJointID -> dVector3
val dJointGetHinge2Anchor2 : dJointID -> dVector3
val dJointGetHinge2Axis1 : dJointID -> dVector3
val dJointGetHinge2Axis2 : dJointID -> dVector3
val dJointGetHinge2Angle1 : dJointID -> float
val dJointGetHinge2Angle1Rate : dJointID -> float
val dJointGetHinge2Angle2Rate : dJointID -> float
val dJointGetUniversalAnchor : dJointID -> dVector3
val dJointGetUniversalAnchor2 : dJointID -> dVector3
val dJointGetUniversalAxis1 : dJointID -> dVector3
val dJointGetUniversalAxis2 : dJointID -> dVector3
val dBodyGetNumJoints : dBodyID -> int
val dBodyGetJoint : dBodyID -> index:int -> dJointID
val dConnectingJoint : dBodyID -> dBodyID -> dJointID
val dConnectingJointList : dBodyID -> dBodyID -> dJointID array
val dJointSetData : dJointID -> data:int -> unit
val dJointGetData : dJointID -> int
val dJointGetType : dJointID -> joint_type
val dJointGetBody : dJointID -> index:int -> dBodyID
type dJointFeedback = {
   f1 : dVector3;
   t1 : dVector3;
   f2 : dVector3;
   t2 : dVector3;
} 
type dJointFeedbackBuffer 
val dJointSetFeedback : dJointID -> dJointFeedbackBuffer
val dJointFeedbackBufferDestroy : dJointFeedbackBuffer -> unit

frees the memory of the buffer (destroy the associated world and/or joint won't free this buffer)

val dJointGetFeedback : dJointID -> dJointFeedback
val dJointFeedback_of_buffer : dJointFeedbackBuffer -> dJointFeedback

Space

val dSimpleSpaceCreate : dSpaceID option -> dSpaceID
val dHashSpaceCreate : dSpaceID option -> dSpaceID
val dQuadTreeSpaceCreate : dSpaceID option ->
       center:dVector3 ->
       extents:dVector3 -> depth:int -> dSpaceID
val dSpaceDestroy : dSpaceID -> unit
val dHashSpaceSetLevels : dSpaceID -> minlevel:int -> maxlevel:int -> unit
val dHashSpaceGetLevels : dSpaceID -> int * int
val dSpaceAdd : dSpaceID -> 'a dGeomID -> unit
val dSpaceRemove : dSpaceID -> 'a dGeomID -> unit
val dSpaceCollide : dSpaceID ->
       ('a dGeomID -> 'b dGeomID -> unit) -> unit
val dSpaceCollide2 : 'a dGeomID ->
       'b dGeomID ->
       ('c dGeomID -> 'd dGeomID -> unit) -> unit
val dSpaceSetCleanup : dSpaceID -> mode:bool -> unit
val dSpaceGetCleanup : dSpaceID -> bool
val dSpaceClean : dSpaceID -> unit
val dSpaceQuery : dSpaceID -> 'a dGeomID -> bool
val dSpaceGetNumGeoms : dSpaceID -> unit
val dSpaceGetGeom : dSpaceID -> i:int -> 'a dGeomID
val dSpaceGetGeomsArray : dSpaceID -> 'a dGeomID array

Geometry

val dCollide : 'a dGeomID ->
       'b dGeomID ->
       max:int -> ('a, 'b) dContactGeom array
val dGeomDestroy : 'a dGeomID -> unit
val dGeomSetBody : 'a dGeomID -> dBodyID option -> unit
val dGeomGetBody : 'a dGeomID -> dBodyID option
val dGeomSetPosition : 'a dGeomID -> x:float -> y:float -> z:float -> unit
val dGeomSetRotation : 'a dGeomID -> dMatrix3 -> unit
val dGeomSetQuaternion : 'a dGeomID -> dQuaternion -> unit
val dGeomGetPosition : 'a dGeomID -> dVector3
val dGeomGetRotation : 'a dGeomID -> dMatrix3
val dGeomGetQuaternion : 'a dGeomID -> dQuaternion
val dGeomGetAABB : 'a dGeomID -> float array
val dInfiniteAABB : 'a dGeomID -> float array

Geometry kind

type sphere_geom 
type box_geom 
type plane_geom 
type heightfield_geom 
type trimesh_geom 
type convex_geom 
type capsule_geom 
type cylinder_geom 
type ray_geom 
type geomTransform_geom 
type geom_class =
| SphereClass
| BoxClass
| CapsuleClass
| CylinderClass
| PlaneClass
| RayClass
| ConvexClass
| GeomTransformClass
| TriMeshClass
| HeightfieldClass
| FirstSpaceSimpleSpaceClass
| HashSpaceClass
| LastSpaceQuadTreeSpaceClass
| FirstUserClass
| LastUserClass 
val dGeomGetClass : 'a dGeomID -> geom_class
type geom_type =
| Sphere_geom of sphere_geom dGeomID
| Box_geom of box_geom dGeomID
| Capsule_geom of capsule_geom dGeomID
| Cylinder_geom of cylinder_geom dGeomID
| Plane_geom of plane_geom dGeomID
| Ray_geom of ray_geom dGeomID
| Convex_geom of convex_geom dGeomID
| GeomTransform_geom of geomTransform_geom dGeomID
| TriMesh_geom of trimesh_geom dGeomID
| Heightfield_geom of heightfield_geom dGeomID
| Geom_is_space
| User_class 
val geom_kind : 'a dGeomID -> geom_type
val dCreateSphere : dSpaceID option ->
       radius:float -> sphere_geom dGeomID
val dGeomSphereGetRadius : sphere_geom dGeomID -> float
val dGeomSphereSetRadius : sphere_geom dGeomID -> radius:float -> unit
val dGeomSpherePointDepth : sphere_geom dGeomID ->
       x:float -> y:float -> z:float -> float
val dCreateBox : dSpaceID option ->
       lx:float ->
       ly:float -> lz:float -> box_geom dGeomID
val dGeomBoxGetLengths : box_geom dGeomID -> dVector3
val dGeomBoxSetLengths : box_geom dGeomID ->
       lx:float -> ly:float -> lz:float -> unit
val dGeomBoxPointDepth : box_geom dGeomID ->
       x:float -> y:float -> z:float -> float
val dCreatePlane : dSpaceID option ->
       a:float ->
       b:float -> c:float -> d:float -> plane_geom dGeomID
val dGeomPlaneGetParams : plane_geom dGeomID -> dVector4
val dGeomPlaneSetParams : plane_geom dGeomID ->
       a:float -> b:float -> c:float -> d:float -> unit
val dGeomPlanePointDepth : plane_geom dGeomID ->
       x:float -> y:float -> z:float -> unit
val dCreateCapsule : dSpaceID option ->
       radius:float ->
       length:float -> capsule_geom dGeomID
val dGeomCapsuleGetParams : capsule_geom dGeomID -> float * float
val dGeomCapsuleSetParams : capsule_geom dGeomID ->
       radius:float -> length:float -> unit
val dGeomCapsulePointDepth : capsule_geom dGeomID ->
       x:float -> y:float -> z:float -> unit
val dCreateCylinder : dSpaceID option ->
       radius:float ->
       length:float -> cylinder_geom dGeomID
val dGeomCylinderGetParams : cylinder_geom dGeomID -> float * float
val dGeomCylinderSetParams : cylinder_geom dGeomID ->
       radius:float -> length:float -> unit
val dCreateRay : dSpaceID option ->
       length:float -> ray_geom dGeomID
val dGeomRaySetLength : ray_geom dGeomID -> length:float -> unit
val dGeomRayGetLength : ray_geom dGeomID -> float
val dGeomRaySet : ray_geom dGeomID ->
       px:float -> py:float -> pz:float -> dx:float -> dy:float -> dz:float -> unit
val dGeomRayGet : ray_geom dGeomID ->
       dVector3 * dVector3
val dGeomRaySetParams : ray_geom dGeomID ->
       first_contact:bool -> backface_cull:bool -> unit
val dGeomRayGetParams : ray_geom dGeomID -> bool * bool
val dGeomRaySetClosestHit : ray_geom dGeomID -> closest_hit:bool -> unit
val dGeomRayGetClosestHit : ray_geom dGeomID -> bool
type dTriMeshDataID 
val dGeomTriMeshDataCreate : unit -> dTriMeshDataID
val dGeomTriMeshDataDestroy : dTriMeshDataID -> unit
val dGeomTriMeshDataPreprocess : dTriMeshDataID -> unit

Frees the associated datas (see dGeomTriMeshDataBuild for explanations)

val dGeomTriMeshSetData : trimesh_geom dGeomID ->
       data:dTriMeshDataID -> unit
val dGeomTriMeshGetData : trimesh_geom dGeomID -> dTriMeshDataID
val dGeomTriMeshGetTriMeshDataID : trimesh_geom dGeomID -> dTriMeshDataID
val dGeomTriMeshDataUpdate : dTriMeshDataID -> unit
val dGeomTriMeshDataBuild : dTriMeshDataID ->
       vertices:float array -> indices:int array -> unit

Important: The vertices parameter is not copied for ODE's use so make sure that it is not garbage collected as long as it trimesh is still used. (The indices parameter's datas are copied to a buffer associated with the dTriMeshDataID, which is freed at the same time with the function dGeomTriMeshDataDestroy.)

val dCreateTriMesh : dSpaceID option ->
       dTriMeshDataID ->
       ?tri_cb:'a ->
       ?arr_cb:'b ->
       ?ray_cb:'c -> unit -> trimesh_geom dGeomID

the callbacks are not implemented yet, just omit the optional parameters

val dGeomTriMeshEnableTC : trimesh_geom dGeomID ->
       geom_class -> bool -> unit
val dGeomTriMeshIsTCEnabled : trimesh_geom dGeomID ->
       geom_class -> bool
val dGeomTriMeshClearTCCache : trimesh_geom dGeomID -> unit
val dCreateGeomTransform : dSpaceID option ->
       geomTransform_geom dGeomID
val dGeomTransformSetGeom : geomTransform_geom dGeomID ->
       'a dGeomID option -> unit
val dGeomTransformGetGeom : geomTransform_geom dGeomID ->
       'a dGeomID option
val dGeomTransformSetCleanup : geomTransform_geom dGeomID -> cleanup:bool -> unit
val dGeomTransformGetCleanup : geomTransform_geom dGeomID -> bool
val dGeomTransformSetInfo : geomTransform_geom dGeomID -> cleanup:bool -> unit
val dGeomTransformGetInfo : geomTransform_geom dGeomID -> bool
type dConvexDataID 
val dConvexDataBuild : planes:float array ->
       points:float array -> polygones:int array -> dConvexDataID

Important: the dConvexDataID needs to be freed with dConvexDataDestroy at the end.

val dCreateConvex : dSpaceID option ->
       dConvexDataID -> convex_geom dGeomID
val dGeomSetConvex : convex_geom dGeomID ->
       dConvexDataID -> unit
val dConvexDataDestroy : dConvexDataID -> unit

Important: do not destroy the dConvexDataID as long as the associated convex geom is used.

type dHeightfieldDataID 
val dGeomHeightfieldDataCreate : unit -> dHeightfieldDataID
val dGeomHeightfieldDataDestroy : id:dHeightfieldDataID -> unit
val dCreateHeightfield : dSpaceID option ->
       data:dHeightfieldDataID ->
       placeable:bool -> heightfield_geom dGeomID
val dGeomHeightfieldDataBuild : id:dHeightfieldDataID ->
       height_data:float array ->
       width:float ->
       depth:float ->
       width_samples:int ->
       depth_samples:int ->
       scale:float -> offset:float -> thickness:float -> wrap:bool -> unit
val dGeomSetData : 'a dGeomID -> int -> unit
val dGeomGetData : 'a dGeomID -> int

you can use these functions for example to associate user data to a geometry:

  let geom_data_tbl = Hashtbl.create 16
  let geom_data_count = ref 0
  let dGeomSetData geom ~data =
    let i = !geom_data_count in
    incr geom_data_count;
    Hashtbl.add geom_data_tbl i data;
    dGeomSetData geom i;
  ;;
  let dGeomGetData geom = (Hashtbl.find geom_data_tbl (dGeomGetData geom))
  
val dGeomIsSpace : 'a dGeomID -> bool
val dGeomGetSpace : 'a dGeomID -> dSpaceID
val dGeomSetCategoryBits : 'a dGeomID -> bits:int -> unit
val dGeomSetCollideBits : 'a dGeomID -> bits:int -> unit
val dGeomGetCategoryBits : 'a dGeomID -> int
val dGeomGetCollideBits : 'a dGeomID -> int
if ( ((g1.category_bits & g2.collide_bits) ||
      (g2.category_bits & g1.collide_bits)) == 0) 
val dGeomEnable : 'a dGeomID -> unit
val dGeomDisable : 'a dGeomID -> unit
val dGeomIsEnabled : 'a dGeomID -> bool
val dGeomSetOffsetPosition : 'a dGeomID -> x:float -> y:float -> z:float -> unit
val dGeomSetOffsetRotation : 'a dGeomID -> r:dMatrix3 -> unit
val dGeomSetOffsetQuaternion : 'a dGeomID -> dQuaternion -> unit
val dGeomGetOffsetQuaternion : 'a dGeomID -> dQuaternion
val dGeomSetOffsetWorldPosition : 'a dGeomID -> x:float -> y:float -> z:float -> unit
val dGeomSetOffsetWorldRotation : 'a dGeomID -> dMatrix3 -> unit
val dGeomSetOffsetWorldQuaternion : 'a dGeomID -> dQuaternion -> unit
val dGeomClearOffset : 'a dGeomID -> unit
val dGeomIsOffset : 'a dGeomID -> bool
val dGeomGetOffsetPosition : 'a dGeomID -> dVector3
val dGeomGetOffsetRotation : 'a dGeomID -> dMatrix3

Mass functions

Note that dMass objects are garbage collected.

val dMassCreate : unit -> dMass
val dMass_set_mass : dMass -> float -> unit
val dMass_mass : dMass -> float
val dMass_set_c : dMass -> dVector4 -> unit
val dMass_c : dMass -> dVector4
val dMass_set_I : dMass -> dMatrix3 -> unit
val dMass_I : dMass -> dMatrix3
val dMassSetZero : dMass -> unit
val dMassSetParameters : dMass ->
       mass:float ->
       cgx:float ->
       cgy:float ->
       cgz:float ->
       i11:float ->
       i22:float -> i33:float -> i12:float -> i13:float -> i23:float -> unit
val dMassSetSphere : dMass -> density:float -> radius:float -> unit
val dMassSetSphereTotal : dMass -> total_mass:float -> radius:float -> unit
val dMassSetBox : dMass ->
       density:float -> lx:float -> ly:float -> lz:float -> unit
val dMassSetBoxTotal : dMass ->
       total_mass:float -> lx:float -> ly:float -> lz:float -> unit
type direction =
| Dir_x
| Dir_y
| Dir_z 
val dMassSetCapsule : dMass ->
       density:float ->
       direction:direction -> radius:float -> length:float -> unit
val dMassSetCapsuleTotal : dMass ->
       total_mass:float ->
       direction:direction -> radius:float -> length:float -> unit
val dMassSetCylinder : dMass ->
       density:float ->
       direction:direction -> radius:float -> length:float -> unit
val dMassSetCylinderTotal : dMass ->
       total_mass:float ->
       direction:direction -> radius:float -> length:float -> unit
val dMassSetTrimesh : dMass ->
       density:float -> trimesh_geom dGeomID -> unit
val dMassSetTrimeshTotal : dMass ->
       total_mass:float -> trimesh_geom dGeomID -> unit
val dMassCheck : dMass -> bool
val dMassAdjust : dMass -> float -> unit
val dMassTranslate : dMass -> x:float -> y:float -> z:float -> unit
val dMassRotate : dMass -> dMatrix3 -> unit
val dMassAdd : dMass -> dMass -> unit

Matrices

val dRGetIdentity : unit -> dMatrix3
val dRFromAxisAndAngle : ax:float -> ay:float -> az:float -> angle:float -> dMatrix3
val dRFromEulerAngles : phi:float -> theta:float -> psi:float -> dMatrix3

Quaternion

val dQGetIdentity : unit -> dQuaternion
val dQFromAxisAndAngle : ax:float -> ay:float -> az:float -> angle:float -> dQuaternion

Misc

val dWorldImpulseToForce : dWorldID ->
       stepsize:float -> ix:float -> iy:float -> iz:float -> dVector3
val dQtoR : dQuaternion -> dMatrix3
val dPlaneSpace : n:dVector3 -> dVector3 * dVector3