lugre_ode_L.cpp

Go to the documentation of this file.

#include "lugre_prefix.h"
#include "lugre_luabind.h"
#include "lugre_fifo.h"
#include "lugre_scripting.h"

extern "C" {
    #include "lua.h"
    #include "lauxlib.h"
    #include "lualib.h"
}

#ifdef ENABLE_ODE

#include <ode/ode.h>

using namespace Lugre;

#define PUSHUDATA(x)        lua_pushlightuserdata(L,reinterpret_cast<void*>(x))
#define PUSHNUMBER(x)       lua_pushnumber(L,(x))
#define PUSHBOOL(x)         lua_pushboolean(L,(x))
#define PUSHVEC_(x,n)       PUSHNUMBER(x[(n)+0]);PUSHNUMBER(x[(n)+1]);PUSHNUMBER(x[(n)+2])
#define PUSHVEC(x)          PUSHVEC_(x,0)
#define PUSHQUAT_(x,n)      PUSHNUMBER(x[(n)+0]);PUSHNUMBER(x[(n)+1]);PUSHNUMBER(x[(n)+2]);PUSHNUMBER(x[(n)+3])
#define PUSHQUAT(x)         PUSHQUAT_(x,0)

#define GETFIFO(n)          (cLuaBind<cFIFO>::checkudata(L,n))
#define GETBOOL(n)          luaL_checkbool(L,n)
#define GETNUMBER(n)        luaL_checknumber(L,n)
#define GETINT(n)           ((int)GETNUMBER(n))
#define GETUINT(n)          ((unsigned int)GETNUMBER(n))
#define GETLONG(n)          ((long)GETNUMBER(n))
#define GETULONG(n)         ((unsigned long)GETNUMBER(n))
#define GETSTRING(n)        luaL_checkstring(L,n)
#define GETUDATA(n)         lua_touserdata(L,n)
#define GETVEC(n)           GETNUMBER((n)+0),GETNUMBER((n)+1),GETNUMBER((n)+2)
#define GETQUAT(n,v)        v[0] = GETNUMBER((n)+0);v[1] = GETNUMBER((n)+1);v[2] = GETNUMBER((n)+2);v[3] = GETNUMBER((n)+3)
// lua w,x,y,z <-> ode 3 0 1 2
#define QUAT4(n,q)          dQuaternion q; q[0] = GETNUMBER((n)+0); q[1] = GETNUMBER((n)+1); q[2] = GETNUMBER((n)+2); q[3] = GETNUMBER((n)+3)
#define VEC3_(n,v)          v[0] = GETNUMBER((n)+0); v[1] = GETNUMBER((n)+1); v[2] = GETNUMBER((n)+2)
#define VEC3(n,v)           dVector3 v; VEC3_(n,v)

#define GEOMID(n)           ((dGeomID)(lua_touserdata(L,n)))
#define BODYID(n)           ((dBodyID)(lua_touserdata(L,n)))
#define SPACEID(n)          ((dSpaceID)(lua_touserdata(L,n)))
#define WORLDID(n)          ((dWorldID)(lua_touserdata(L,n)))
#define JOINTGROUPID(n)     ((dJointGroupID)(lua_touserdata(L,n)))
#define JOINTID(n)          ((dJointID)(lua_touserdata(L,n)))
#define MASSID(n)           ((dMass *)(lua_touserdata(L,n)))
#define STOPWATCHID(n)      ((dStopwatch *)(lua_touserdata(L,n)))
#define CONTACTGEOMID(n)    ((dContactGeom *)(lua_touserdata(L,n)))
#define JOINTFEEDBACKID(n)  ((dJointFeedback *)(lua_touserdata(L,n)))
#define TRIMESHDATAID(n)    ((dTriMeshDataID)(lua_touserdata(L,n)))
#define TRIMESHRAWDATAID(n) ((cTriangleMeshRawData *)(lua_touserdata(L,n)))
#define HEIGHTFIELDDATAID(n)    ((dHeightfieldDataID)(lua_touserdata(L,n)))
#define CONTACTID(n)        ((dContact *)(lua_touserdata(L,n)))



/*
typedef dReal dVector3[4];
typedef dReal dVector4[4];
typedef dReal dMatrix3[4*3];
typedef dReal dMatrix4[4*4];
typedef dReal dMatrix6[8*6];
typedef dReal dQuaternion[4];
*/


static void stackDump (lua_State *L) {
  int i;
  int top = lua_gettop(L);
  for (i = 1; i <= top; i++) {  /* repeat for each level */
    int t = lua_type(L, i);
    switch (t) {

      case LUA_TSTRING:  /* strings */
        printf("`%s'", lua_tostring(L, i));
        break;

      case LUA_TBOOLEAN:  /* booleans */
        printf(lua_toboolean(L, i) ? "true" : "false");
        break;

      case LUA_TNUMBER:  /* numbers */
        printf("%g", lua_tonumber(L, i));
        break;

      default:  /* other values */
        printf("%s", lua_typename(L, t));
        break;

    }
    printf("  ");  /* put a separator */
  }
  printf("\n");  /* end the listing */
}
    


struct sCallbackData {
    int fun;
    lua_State *L;
};



// lua_pushlightuserdata(L,reinterpret_cast<void*>(iRemoteAddr));
// uint32 iServerAddr = (uint32)(long)(lua_touserdata(L,3));

// lua : void OdeGeomSetData(dGeomID geom, void* data) [ from ode ]
static int l_OdeGeomSetData (lua_State *L) { PROFILE
    dGeomSetData(GEOMID(1), lua_touserdata(L,2));
    return 0;
}

// lua : udata OdedGeomGetData(dGeomID geom) [ from ode ]
static int l_OdeGeomGetData (lua_State *L) { PROFILE
    PUSHUDATA( dGeomGetData(GEOMID(1)) );
    return 1;
}

// lua : void OdeGeomSetBody(dGeomID geom, dBodyID body) [ from ode ]
static int l_OdeGeomSetBody (lua_State *L) { PROFILE
    dGeomSetBody(GEOMID(1), BODYID(2));
    return 0;
}

// lua : dBodyID OdeGeomGetBody(dGeomID geom) [ from ode ]
static int l_OdeGeomGetBody (lua_State *L) { PROFILE
    PUSHUDATA( dGeomGetBody(GEOMID(1)) );
    return 1;
}

// lua : void OdeGeomSetPosition(dGeomID geom, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomSetPosition (lua_State *L) { PROFILE
    dGeomSetPosition(GEOMID(1), GETVEC(2));
    return 0;
}

// lua : void OdeGeomSetQuaternion(dGeomID geom, const dQuaternion Q) [ from ode ]
static int l_OdeGeomSetQuaternion (lua_State *L) { PROFILE
    dQuaternion q;
    GETQUAT(2,q);
    dGeomSetQuaternion(GEOMID(1), q);
    return 0;
}

// lua : x,y,z OdeGeomGetPosition(dGeomID geom) [ from ode ]
static int l_OdeGeomGetPosition (lua_State *L) { PROFILE
    const dReal *x = dGeomGetPosition(GEOMID(1));
    PUSHVEC(x);
    return 3;
}

// lua : w,x,y,z OdeGeomGetQuaternion(dGeomID geom) [ from ode ]
static int l_OdeGeomGetQuaternion (lua_State *L) { PROFILE
    dQuaternion q;
    dGeomGetQuaternion(GEOMID(1), q);
    PUSHQUAT(q);
    return 4;
}

// lua : ax,ay,az,bx,by,bz OdeGeomGetAABB(dGeomID geom) [ from ode ]
static int l_OdeGeomGetAABB (lua_State *L) { PROFILE
    dReal aabb[6];
    dGeomGetAABB(GEOMID(1), aabb);
    PUSHVEC_(aabb,0);
    PUSHVEC_(aabb,3);
    return 6;
}

// lua : int OdeGeomIsSpace(dGeomID geom) [ from ode ]
static int l_OdeGeomIsSpace (lua_State *L) { PROFILE
    PUSHBOOL(dGeomIsSpace(GEOMID(1)));
    return 1;
}

// lua : dSpaceID OdeGeomGetSpace(dGeomID) [ from ode ]
static int l_OdeGeomGetSpace (lua_State *L) { PROFILE
    PUSHUDATA(dGeomGetSpace(GEOMID(1)));
    return 1;
}

// lua : int OdeGeomGetClass(dGeomID geom) [ from ode ]
static int l_OdeGeomGetClass (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomGetClass(GEOMID(1)) );
    return 1;
}

// lua : void OdeGeomSetCategoryBits(dGeomID geom, unsigned long bits) [ from ode ]
static int l_OdeGeomSetCategoryBits (lua_State *L) { PROFILE
    dGeomSetCategoryBits(GEOMID(1), GETULONG(2));
    return 0;
}

// lua : void OdeGeomSetCollideBits(dGeomID geom, unsigned long bits) [ from ode ]
static int l_OdeGeomSetCollideBits (lua_State *L) { PROFILE
    dGeomSetCollideBits(GEOMID(1), GETULONG(2));
    return 0;
}

// lua : long OdeGeomGetCategoryBits(dGeomID) [ from ode ]
static int l_OdeGeomGetCategoryBits (lua_State *L) { PROFILE
    PUSHNUMBER(dGeomGetCategoryBits(GEOMID(1)));
    return 1;
}

// lua : long OdeGeomGetCollideBits(dGeomID) [ from ode ]
static int l_OdeGeomGetCollideBits (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomGetCollideBits(GEOMID(1)) );
    return 1;
}

// lua : void OdeGeomEnable(dGeomID geom) [ from ode ]
static int l_OdeGeomEnable (lua_State *L) { PROFILE
    dGeomEnable(GEOMID(1));
    return 0;
}

// lua : void OdeGeomDisable(dGeomID geom) [ from ode ]
static int l_OdeGeomDisable (lua_State *L) { PROFILE
    dGeomDisable(GEOMID(1));
    return 0;
}

// lua : int OdeGeomIsEnabled(dGeomID geom) [ from ode ]
static int l_OdeGeomIsEnabled (lua_State *L) { PROFILE
    PUSHBOOL(dGeomIsEnabled(GEOMID(1)));
    return 1;
}

/* ************************************************************************ */
/* geom offset from body */

// lua : void OdeGeomSetOffsetPosition(dGeomID geom, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomSetOffsetPosition (lua_State *L) { PROFILE
    dGeomSetOffsetPosition(GEOMID(1), GETVEC(2));
    return 0;
}


// lua : void OdeGeomSetOffsetQuaternion(dGeomID geom, const dQuaternion Q) [ from ode ]
static int l_OdeGeomSetOffsetQuaternion (lua_State *L) { PROFILE
    QUAT4(2,q);
    dGeomSetOffsetQuaternion(GEOMID(1), q);
    return 0;
}

// lua : void OdeGeomSetOffsetWorldPosition(dGeomID geom, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomSetOffsetWorldPosition (lua_State *L) { PROFILE
    dGeomSetOffsetWorldPosition(GEOMID(1), GETVEC(2));
    return 0;
}


// lua : void OdeGeomSetOffsetWorldQuaternion(dGeomID geom, const dQuaternion) [ from ode ]
static int l_OdeGeomSetOffsetWorldQuaternion (lua_State *L) { PROFILE
    QUAT4(2,q);
    dGeomSetOffsetWorldQuaternion(GEOMID(1), q);
    return 0;
}

// lua : void OdeGeomClearOffset(dGeomID geom) [ from ode ]
static int l_OdeGeomClearOffset (lua_State *L) { PROFILE
    dGeomClearOffset(GEOMID(1));
    return 0;
}

// lua : int OdeGeomIsOffset(dGeomID geom) [ from ode ]
static int l_OdeGeomIsOffset (lua_State *L) { PROFILE
    PUSHNUMBER(dGeomIsOffset(GEOMID(1)));
    return 1;
}

// lua : x,y,z OdeGeomGetOffsetPosition(dGeomID geom) [ from ode ]
static int l_OdeGeomGetOffsetPosition (lua_State *L) { PROFILE
    const dReal *x = dGeomGetOffsetPosition(GEOMID(1));
    PUSHVEC(x);
    return 3;
}


// lua : w,x,y,z OdeGeomGetOffsetQuaternion(dGeomID geom, dQuaternion result) [ from ode ]
static int l_OdeGeomGetOffsetQuaternion (lua_State *L) { PROFILE
    dQuaternion result;
    dGeomGetOffsetQuaternion(GEOMID(1), result);
    PUSHQUAT(result);
    return 4;
}

/* ************************************************************************ */
/* collision detection */

/*
// lua : int OdeCollide(dGeomID o1, dGeomID o2, int flags, dContactGeom *contact,int skip) [ from ode ]
static int l_OdeCollide (lua_State *L) { PROFILE
    int skip = sizeof(dContactGeom);

    if(lua_gettop(L) == 5)skip = GETINT(5);

    PUSHNUMBER(dCollide(GEOMID(1), GEOMID(2), GETINT(3), CONTACTGEOMID(4),skip));
    return 1;
}
*/

/*
  typedef struct dContactGeom {
  dVector3 pos;          ///< contact position
  dVector3 normal;       ///< normal vector
  dReal depth;           ///< penetration depth
  dGeomID g1,g2;         ///< the colliding geoms
  int side1,side2;       ///< (to be documented)
} dContactGeom;
*/
// lua : px,py,pz, nx,ny,nz, depth, g1,g2, side1, side2 OdeContactGeomCreate(contactgeomid)
static int l_OdeContactGeomGetParams (lua_State *L) { PROFILE
    dContactGeom *p = CONTACTGEOMID(1);
    if(p){
        PUSHVEC(p->pos);

        PUSHVEC(p->normal);
        
        PUSHNUMBER(p->depth);
        
        PUSHUDATA(p->g1);
        PUSHUDATA(p->g2);
        
        PUSHNUMBER(p->side1);
        PUSHNUMBER(p->side2);
        
        return 11;
    } else return 0;
}

static int l_OdeContactGeomCreate (lua_State *L) { PROFILE
    dContactGeom *p = new dContactGeom;
    PUSHUDATA( p );
    return 1;
}

static int l_OdeContactGeomDestroy (lua_State *L) { PROFILE
    dContactGeom *p = CONTACTGEOMID(1);
    if(p)delete p;
    return 0;
}

void nearCallbackLua(void *data, dGeomID o0, dGeomID o1) {
    if (dGeomIsSpace (o0) || dGeomIsSpace (o1)) {
        // colliding a space with something
        dSpaceCollide2 (o0,o1,data,&nearCallbackLua);
        // collide all geoms internal to the space(s)
        if (dGeomIsSpace (o0)) dSpaceCollide((dSpaceID)o0,data,&nearCallbackLua);
        if (dGeomIsSpace (o1)) dSpaceCollide((dSpaceID)o1,data,&nearCallbackLua);
    } else {
        sCallbackData *d = (sCallbackData *) data;
        //printf("nearCallbackLua: fun(%x,%x)\n",o0,o1);
        //printf("                 body(%x,%x)\n",dGeomGetBody(o0),dGeomGetBody(o1));
        lua_rawgeti(d->L, LUA_REGISTRYINDEX, d->fun);
        lua_pushlightuserdata(d->L,reinterpret_cast<void*>(o0));
        lua_pushlightuserdata(d->L,reinterpret_cast<void*>(o1));
        lua_call(d->L, 2, 0); // TODO : see also PCallWithErrFuncWrapper for protected call in case of error (for error messages)
    }
}   


// lua : {contact,...} OdeCollide(dGeomID o1, dGeomID o2,count)
static int l_OdeCollide (lua_State *L) { PROFILE
    dGeomID o0 = GEOMID(1);
    dGeomID o1 = GEOMID(2);
    //int flags = GETINT(3);
    int count = GETINT(3);
    
    // Create an array of dContact objects to hold the contact joints
    static const int MAX_CONTACTS = 10;
    static dContact contact[MAX_CONTACTS];

    if(count > MAX_CONTACTS)count = MAX_CONTACTS;

    if (int numc = dCollide(o0, o1, count, &contact[0].geom, sizeof(dContact))){
        // To add each contact point found to our joint group we call dJointCreateContact which is just one of the many
        // different joint types available.  
        lua_newtable(L);
        for (int i = 0; i < numc; i++){
            lua_pushlightuserdata( L, reinterpret_cast<void*>(contact + i));
            lua_rawseti( L, -2, i );
        }
        return 1;
    }   
        
    return 0;
}

/*
  int mode;
  dReal mu;

  dReal mu2;
  dReal bounce;
  dReal bounce_vel;
  dReal soft_erp;
  dReal soft_cfm;
  dReal motion1,motion2;
  dReal slip1,slip2;
} dSurfaceParameters;
*/
// lua : mode,mu,mu2,bounce,bounce_vel,soft_erp,soft_cfm,motion1,motion2,slip1,slip2 OdeGetContactSurface(dContact *p)
static int l_OdeGetContactSurface (lua_State *L) { PROFILE
    dSurfaceParameters *p = &(CONTACTID(1)->surface);
    //1
    PUSHNUMBER(p->mode);
    PUSHNUMBER(p->mu);
    //3
    PUSHNUMBER(p->mu2);
    PUSHNUMBER(p->bounce);
    //5
    PUSHNUMBER(p->bounce_vel);
    PUSHNUMBER(p->soft_erp);
    //7
    PUSHNUMBER(p->soft_cfm);
    PUSHNUMBER(p->motion1);
    //9
    PUSHNUMBER(p->motion2);
    PUSHNUMBER(p->slip1);
    //11
    PUSHNUMBER(p->slip2);
    return 11;
}
    
// lua : OdeSetContactSurface(dContact *p,mode,mu,mu2,bounce,bounce_vel,soft_erp,soft_cfm,motion1,motion2,slip1,slip2)
static int l_OdeSetContactSurface (lua_State *L) { PROFILE
    dSurfaceParameters *p = &(CONTACTID(1)->surface);
    p->mode = GETINT(2);
    p->mu = GETNUMBER(3);
    p->mu2 = GETNUMBER(4);
    p->bounce = GETNUMBER(5);
    p->bounce_vel = GETNUMBER(6);
    p->soft_erp = GETNUMBER(7);
    p->soft_cfm = GETNUMBER(8);
    p->motion1 = GETNUMBER(9);
    p->motion2 = GETNUMBER(10);
    p->slip1 = GETNUMBER(11);
    p->slip2 = GETNUMBER(12);
    return 0;
}
 
 /*
typedef struct dContactGeom {
  dVector3 pos;          ///< contact position
  dVector3 normal;       ///< normal vector
  dReal depth;           ///< penetration depth
  dGeomID g1,g2;         ///< the colliding geoms
  int side1,side2;       ///< (to be documented)
} dContactGeom;
*/  

// lua : OdeSetContactGeom(dContact *p,mode,mu,mu2,bounce,bounce_vel,soft_erp,soft_cfm,motion1,motion2,slip1,slip2)
static int l_OdeSetContactGeom (lua_State *L) { PROFILE
    dContactGeom *p = &(CONTACTID(1)->geom);
    //2
    VEC3_(2,p->pos);
    //5
    VEC3_(5,p->normal);
    //8
    p->depth = GETNUMBER(8);
    p->g1 = GEOMID(9);
    p->g2 = GEOMID(10);
    //11
    p->side1 = GETINT(11);
    p->side2 = GETINT(12);
    return 0;
}
    
// lua : posx,posy,posz,normalx,normaly,normalz,depth,g1,g2,side1,side2 OdeGetContactGeom(dContact *p)
static int l_OdeGetContactGeom (lua_State *L) { PROFILE
    dContactGeom *p = &(CONTACTID(1)->geom);
    //1
    PUSHVEC(p->pos);
    //4
    PUSHVEC(p->normal);
    //7
    PUSHNUMBER(p->depth);
    PUSHUDATA(p->g1);   
    PUSHUDATA(p->g2);   
    //10
    PUSHNUMBER(p->side1);
    PUSHNUMBER(p->side2);
    
    return 11;
}

 
// lua : void OdeSpaceCollide(dSpaceID space,fun(o0,o1))
static int l_OdeSpaceCollide (lua_State *L) { PROFILE
    sCallbackData data;
    
    data.L = L;
    data.fun = luaL_ref(L, LUA_REGISTRYINDEX);
    
    dSpaceID space = SPACEID(1);
    lua_pop(L,1);
    
    dSpaceCollide(space, &data, &nearCallbackLua);
    
    luaL_unref(L, LUA_REGISTRYINDEX, data.fun);
    
    return 0;
}

/*
// like OdeSpaceCollide but with an additional callback function
// fun() : function to create the collision feedback joints
//         function callback(o0,o1,posx,posy,posz,normalx,normaly,normalz,depth,g1,g2,side1,side2) 
//           return mode,mu,mu2,bounce,bounce_vel,soft_erp,soft_cfm,motion1,motion2,slip1,slip2  
//         end
// lua : void OdeSpaceCollideWithCallback(dWorldID, dJointGroupID, dSpaceID space,fun())
static int l_OdeSpaceCollideWithCallback (lua_State *L) { PROFILE
    sCollisionData data;

    data.fun = luaL_ref(L, LUA_REGISTRYINDEX);

    data.world = WORLDID(1);
    data.contactgroup = JOINTGROUPID(2);
    dSpaceID space = SPACEID(3);
    
    lua_pop(L, 3);
    
    data.L = L;
    
    dSpaceCollide(space, &data, &nearCallback);

    luaL_unref(L, LUA_REGISTRYINDEX, data.fun);

    return 0;
}
*/

// lua : void OdeSpaceCollide2(dGeomID space1, dGeomID space2, fun(o0,o1))
static int l_OdeSpaceCollide2 (lua_State *L) { PROFILE
    sCallbackData data;
    
    data.L = L;
    data.fun = luaL_ref(L, LUA_REGISTRYINDEX);
    
    dGeomID space1 = GEOMID(1);
    dGeomID space2 = GEOMID(2);
    
    lua_pop(L,2);
    
    dSpaceCollide2(space1, space2, &data, &nearCallbackLua);

    luaL_unref(L, LUA_REGISTRYINDEX, data.fun);
    
    return 0;
}

// lua : dGeomID OdeCreateSphere(dSpaceID space, dReal radius) [ from ode ]
static int l_OdeCreateSphere (lua_State *L) { PROFILE
    PUSHUDATA( dCreateSphere(SPACEID(1), GETNUMBER(2)) );
    return 1;
}

// lua : void OdeGeomSphereSetRadius(dGeomID sphere, dReal radius) [ from ode ]
static int l_OdeGeomSphereSetRadius (lua_State *L) { PROFILE
    dGeomSphereSetRadius(GEOMID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeGeomSphereGetRadius(dGeomID sphere) [ from ode ]
static int l_OdeGeomSphereGetRadius (lua_State *L) { PROFILE
    PUSHNUMBER(dGeomSphereGetRadius(GEOMID(1)));
    return 1;
}

// lua : dReal OdeGeomSpherePointDepth(dGeomID sphere, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomSpherePointDepth (lua_State *L) { PROFILE
    PUSHNUMBER(dGeomSpherePointDepth(GEOMID(1), GETVEC(2)));
    return 1;
}

//--> Convex Functions
// lua : dGeomID OdeCreateConvex(dSpaceID space,dReal *_planes,unsigned int _planecount,dReal *_points,unsigned int _pointcount,unsigned int *_polygons) [ from ode ]
static int l_OdeCreateConvex (lua_State *L) { PROFILE
    // TODO dCreateConvex(dSpaceID space,dReal *_planes,unsigned int _planecount,dReal *_points,unsigned int _pointcount,unsigned int *_polygons);
    return 0;
}


// lua : void OdeGeomSetConvex(dGeomID g,dReal *_planes,unsigned int _count,dReal *_points,unsigned int _pointcount,unsigned int *_polygons) [ from ode ]
static int l_OdeGeomSetConvex (lua_State *L) { PROFILE
    // TODO dGeomSetConvex(dGeomID g,dReal *_planes,unsigned int _count,dReal *_points,unsigned int _pointcount,unsigned int *_polygons);
    return 0;
}

//<-- Convex Functions

// lua : dGeomID OdeCreateBox(dSpaceID space, dReal lx, dReal ly, dReal lz) [ from ode ]
static int l_OdeCreateBox (lua_State *L) { PROFILE
    PUSHUDATA(dCreateBox(SPACEID(1), GETVEC(2)));
    return 1;
}

// lua : void OdeGeomBoxSetLengths(dGeomID box, dReal lx, dReal ly, dReal lz) [ from ode ]
static int l_OdeGeomBoxSetLengths (lua_State *L) { PROFILE
    dGeomBoxSetLengths(GEOMID(1), GETVEC(2));
    return 0;
}

// lua : lx,ly,lz OdeGeomBoxGetLengths(dGeomID box, dVector3 result) [ from ode ]
static int l_OdeGeomBoxGetLengths (lua_State *L) { PROFILE
    dVector3 result;
    dGeomBoxGetLengths(GEOMID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeGeomBoxPointDepth(dGeomID box, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomBoxPointDepth (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomBoxPointDepth(GEOMID(1), GETVEC(2)) );
    return 1;
}


// lua : dGeomID OdeCreatePlane(dSpaceID space, dReal a, dReal b, dReal c, dReal d) [ from ode ]
static int l_OdeCreatePlane (lua_State *L) { PROFILE
    PUSHUDATA( dCreatePlane(SPACEID(1), GETVEC(2), GETNUMBER(5)) );
    return 1;
}


// lua : void OdeGeomPlaneSetParams(dGeomID plane, dReal a, dReal b, dReal c, dReal d) [ from ode ]
static int l_OdeGeomPlaneSetParams (lua_State *L) { PROFILE
    dGeomPlaneSetParams(GEOMID(1), GETVEC(2), GETNUMBER(5));
    return 0;
}


// lua : a,b,c,d OdeGeomPlaneGetParams(dGeomID plane, dVector4 result) [ from ode ]
static int l_OdeGeomPlaneGetParams (lua_State *L) { PROFILE
    dVector4 result;
    dGeomPlaneGetParams(GEOMID(1), result);
    PUSHVEC(result);
    PUSHNUMBER(result[3]);
    return 4;
}


// lua : dReal OdeGeomPlanePointDepth(dGeomID plane, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomPlanePointDepth (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomPlanePointDepth(GEOMID(1), GETVEC(2)) );
    return 1;
}


// lua : dGeomID OdeCreateCapsule(dSpaceID space, dReal radius, dReal length) [ from ode ]
static int l_OdeCreateCapsule (lua_State *L) { PROFILE
    PUSHUDATA( dCreateCapsule(SPACEID(1), GETNUMBER(2), GETNUMBER(3)) );
    return 1;
}


// lua : void OdeGeomCapsuleSetParams(dGeomID ccylinder, dReal radius, dReal length) [ from ode ]
static int l_OdeGeomCapsuleSetParams (lua_State *L) { PROFILE
    dGeomCapsuleSetParams(GEOMID(1), GETNUMBER(2), GETNUMBER(3));
    return 0;
}


// lua : r,l OdeGeomCapsuleGetParams(dGeomID ccylinder, dReal *radius, dReal *length) [ from ode ]
static int l_OdeGeomCapsuleGetParams (lua_State *L) { PROFILE
    dReal r,l;
    dGeomCapsuleGetParams(GEOMID(1), &r, &l);
    PUSHNUMBER(r);
    PUSHNUMBER(l);
    return 2;
}


// lua : dReal OdeGeomCapsulePointDepth(dGeomID ccylinder, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeGeomCapsulePointDepth (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomCapsulePointDepth(GEOMID(1), GETVEC(2)) );
    return 1;
}


// lua : void OdeGeomCylinderSetParams(dGeomID cylinder, dReal radius, dReal length) [ from ode ]
static int l_OdeGeomCylinderSetParams (lua_State *L) { PROFILE
    dGeomCylinderSetParams(GEOMID(1), GETNUMBER(2), GETNUMBER(3));
    return 0;
}


// lua : r,l OdeGeomCylinderGetParams(dGeomID cylinder, dReal *radius, dReal *length) [ from ode ]
static int l_OdeGeomCylinderGetParams (lua_State *L) { PROFILE
    dReal r,l;
    dGeomCylinderGetParams(GEOMID(1), &r,&l);
    PUSHNUMBER(r);
    PUSHNUMBER(l);
    return 2;
}


// lua : dGeomID OdeCreateRay(dSpaceID space, dReal length) [ from ode ]
static int l_OdeCreateRay (lua_State *L) { PROFILE
    PUSHUDATA( dCreateRay(SPACEID(1), GETNUMBER(2)) );
    return 1;
}


// lua : void OdeGeomRaySetLength(dGeomID ray, dReal length) [ from ode ]
static int l_OdeGeomRaySetLength (lua_State *L) { PROFILE
    dGeomRaySetLength(GEOMID(1), GETNUMBER(2));
    return 0;
}


// lua : dReal OdeGeomRayGetLength(dGeomID ray) [ from ode ]
static int l_OdeGeomRayGetLength (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomRayGetLength(GEOMID(1)) );
    return 1;
}


// lua : void OdeGeomRaySet(dGeomID ray, dReal px, dReal py, dReal pz,dReal dx, dReal dy, dReal dz) [ from ode ]
static int l_OdeGeomRaySet (lua_State *L) { PROFILE
    dGeomRaySet(GEOMID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : void OdeGeomDestroy(dGeomID)
static int l_OdeGeomDestroy (lua_State *L) { PROFILE
    dGeomDestroy(GEOMID(1));
    return 0;
}


// lua : px,py,pz, dx,dy,dz OdeGeomRayGet(dGeomID ray, dVector3 start, dVector3 dir) [ from ode ]
static int l_OdeGeomRayGet (lua_State *L) { PROFILE
    dVector3 start;
    dVector3 dir;
    dGeomRayGet(GEOMID(1), start, dir);
    PUSHVEC(start);
    PUSHVEC(dir);
    return 6;
}

/*
 * Set/get ray flags that influence ray collision detection.
 * These flags are currently only noticed by the trimesh collider, because
 * they can make a major differences there.
 */
// lua : void OdeGeomRaySetParams(dGeomID g, int FirstContact, int BackfaceCull) [ from ode ]
static int l_OdeGeomRaySetParams (lua_State *L) { PROFILE
    dGeomRaySetParams(GEOMID(1), GETINT(2), GETINT(3));
    return 0;
}


// lua : FirstContact, BackfaceCull OdeGeomRayGetParams(dGeomID g, int *FirstContact, int *BackfaceCull) [ from ode ]
static int l_OdeGeomRayGetParams (lua_State *L) { PROFILE
    int FirstContact, BackfaceCull;
    dGeomRayGetParams(GEOMID(1), &FirstContact, &BackfaceCull);
    PUSHNUMBER(FirstContact);
    PUSHNUMBER(BackfaceCull);
    return 2;
}


// lua : void OdeGeomRaySetClosestHit(dGeomID g, int closestHit) [ from ode ]
static int l_OdeGeomRaySetClosestHit (lua_State *L) { PROFILE
    dGeomRaySetClosestHit(GEOMID(1), GETINT(2));
    return 0;
}


// lua : int OdeGeomRayGetClosestHit(dGeomID g) [ from ode ]
static int l_OdeGeomRayGetClosestHit (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomRayGetClosestHit(GEOMID(1)) );
    return 1;
}


// lua : void OdeGeomTransformSetGeom(dGeomID g, dGeomID obj) [ from ode ]
static int l_OdeGeomTransformSetGeom (lua_State *L) { PROFILE
    dGeomTransformSetGeom(GEOMID(1), GEOMID(2));
    return 0;
}


// lua : dGeomID OdeGeomTransformGetGeom(dGeomID g) [ from ode ]
static int l_OdeGeomTransformGetGeom (lua_State *L) { PROFILE
    PUSHUDATA( dGeomTransformGetGeom(GEOMID(1)) );
    return 1;
}


// lua : void OdeGeomTransformSetCleanup(dGeomID g, int mode) [ from ode ]
static int l_OdeGeomTransformSetCleanup (lua_State *L) { PROFILE
    dGeomTransformSetCleanup(GEOMID(1), GETINT(2));
    return 0;
}


// lua : int OdeGeomTransformGetCleanup(dGeomID g) [ from ode ]
static int l_OdeGeomTransformGetCleanup (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomTransformGetCleanup(GEOMID(1)) );
    return 1;
}


// lua : void OdeGeomTransformSetInfo(dGeomID g, int mode) [ from ode ]
static int l_OdeGeomTransformSetInfo (lua_State *L) { PROFILE
    dGeomTransformSetInfo(GEOMID(1), GETINT(2));
    return 0;
}


// lua : int OdeGeomTransformGetInfo(dGeomID g) [ from ode ]
static int l_OdeGeomTransformGetInfo (lua_State *L) { PROFILE
    PUSHNUMBER( dGeomTransformGetInfo(GEOMID(1)) );
    return 1;
}

// lua : dGeomID OdeCreateHeightfield( dSpaceID space,dHeightfieldDataID data, int bPlaceable ) [ from ode ]
static int l_OdeCreateHeightfield (lua_State *L) { PROFILE
    PUSHUDATA( dCreateHeightfield( SPACEID(1), HEIGHTFIELDDATAID(2), GETINT(3) ) );
    return 1;
}

// lua : void OdeGeomHeightfieldDataDestroy( dHeightfieldDataID d ) [ from ode ]
static int l_OdeGeomHeightfieldDataDestroy (lua_State *L) { PROFILE
    dGeomHeightfieldDataDestroy( HEIGHTFIELDDATAID(1) );
    return 0;
}

// lua : dHeightfieldDataID OdeGeomHeightfieldDataCreate() [ from ode ]
static int l_OdeGeomHeightfieldDataCreate (lua_State *L) { PROFILE
    PUSHUDATA( dGeomHeightfieldDataCreate() );
    return 1;
}


// lua : void OdeGeomHeightfieldDataBuildCallback( dHeightfieldDataID d,void* pUserData, dHeightfieldGetHeight* pCallback,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap ) [ from ode ]
static int l_OdeGeomHeightfieldDataBuildCallback (lua_State *L) { PROFILE
    // TODO dGeomHeightfieldDataBuildCallback( dHeightfieldDataID d,void* pUserData, dHeightfieldGetHeight* pCallback,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap );
    return 0;
}


float CallLuaGetHeightFun(lua_State *L, int fun,const float x,const float z){
    lua_rawgeti(L, LUA_REGISTRYINDEX, fun);
    lua_pushnumber(L, x);
    lua_pushnumber(L, z);
    lua_call(L, 2, 1); // TODO : see also PCallWithErrFuncWrapper for protected call in case of error (for error messages)
    float r = GETNUMBER(lua_gettop(L));
    lua_pop(L, 1);
    return r;
}

#define HF_BUFFERINDEX(w,h,x,z) ((w)*(z)+(x))

// lua : void OdeGeomHeightfieldDataBuildFromFun( dHeightfieldDataID d,width,height,dx,dz,float fun(x,z))
static int l_OdeGeomHeightfieldDataBuildFromFun (lua_State *L) { PROFILE
    dHeightfieldDataID hf = HEIGHTFIELDDATAID(1);
    float w = GETNUMBER(2);
    float h = GETNUMBER(3);
    float dx = GETNUMBER(4);
    float dz = GETNUMBER(5);
    
    int px = (int)floor(w / dx);
    int pz = (int)floor(h / dz);
    
    // stores the given lua function in the registry
    int fun = luaL_ref(L, LUA_REGISTRYINDEX);
    
    // clears the lua stack that we can call the given lua function
    lua_pop(L, 5);
    
    int bw = px + 1;
    int bh = pz + 1;
    
    float *fdata = new float[bw * bh];
    
    for(int x=0;x <= px;++x)
        for(int z=0;z <= pz;++z){
            //printf("[%f,%f]",(float)x*dx,(float)y*dy);
            float y = CallLuaGetHeightFun(L,fun,(float)x*dx,(float)z*dz);
            //printf(" => %f\n",z);
            
            fdata[HF_BUFFERINDEX(bw,bh,x,z)] = y;
        }
    
    float min = fdata[0];
    float max = fdata[0];
    
    for(int x=0;x <= px;++x)
        for(int z=0;z <= pz;++z){
            float y = fdata[HF_BUFFERINDEX(bw,bh,x,z)];
            if(y > max)max = y;
            if(y < min)min = y;
        }   

    if(0){ // byte
        float offset = min;
        float dy = max - min;
        float scale = dy / 255.0f;
        
        unsigned char *bdata = new unsigned char[bw * bh];

        for(int x=0;x <= px;++x)
            for(int z=0;z <= pz;++z){
                float y = fdata[HF_BUFFERINDEX(bw,bh,x,z)];
                bdata[HF_BUFFERINDEX(bw,bh,x,z)] = (unsigned char)( ((y - offset) * 255.0f) / dy );
            }   
    
        printf("DEBUG hf=%d  w=%f h=%f px=%d pz=%d offset=%f scale=%f min=%f max=%f\n",hf,w,h,px,pz,offset,scale,min,max);
    
        /*
        for(int x=0;x <= px;++x)
            for(int z=0;z <= pz;++z){
                float y = bdata[HF_BUFFERINDEX(bw,bh,x,z)];
                printf("HF byte: [%f %f] %d -> %f\n",(float)x * dx,(float)z * dz,(int)y,y * scale + offset);
            }   
        */
        
        // return (h * m_fScale) + m_fOffset;
        // dGeomHeightfieldDataBuildByte( dHeightfieldDataID d,const unsigned char* pHeightData, int bCopyHeightData,
        // dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap );
        dGeomHeightfieldDataBuildByte( hf, bdata, true, w, h, px + 1, pz + 1, scale, offset, 1.0f, false);

        delete[] bdata;
    } else { // float
        dGeomHeightfieldDataBuildSingle( hf, fdata, true, w, h, px + 1, pz + 1, 1.0f, 0.0f, 1.0f, false);
        dGeomHeightfieldDataSetBounds(hf, min, max);
    }
    
    delete[] fdata;
    

    // release the given lua function
    luaL_unref(L, LUA_REGISTRYINDEX, fun);

    return 0;
}

// lua : void OdeGeomHeightfieldDataBuildByte( dHeightfieldDataID d,const unsigned char* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness,  int bWrap ) [ from ode ]
static int l_OdeGeomHeightfieldDataBuildByte (lua_State *L) { PROFILE
    // TODO dGeomHeightfieldDataBuildByte( dHeightfieldDataID d,const unsigned char* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness,  int bWrap );
    return 0;
}

// lua : void OdeGeomHeightfieldDataBuildShort( dHeightfieldDataID d,const short* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap ) [ from ode ]
static int l_OdeGeomHeightfieldDataBuildShort (lua_State *L) { PROFILE
    // TODO dGeomHeightfieldDataBuildShort( dHeightfieldDataID d,const short* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap );
    return 0;
}

// lua : void OdeGeomHeightfieldDataBuildSingle( dHeightfieldDataID d,const float* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap ) [ from ode ]
static int l_OdeGeomHeightfieldDataBuildSingle (lua_State *L) { PROFILE
    // TODO dGeomHeightfieldDataBuildSingle( dHeightfieldDataID d,const float* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap );
    return 0;
}

// lua : void OdeGeomHeightfieldDataBuildDouble( dHeightfieldDataID d,const double* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap ) [ from ode ]
static int l_OdeGeomHeightfieldDataBuildDouble (lua_State *L) { PROFILE
    // TODO dGeomHeightfieldDataBuildDouble( dHeightfieldDataID d,const double* pHeightData, int bCopyHeightData,dReal width, dReal depth, int widthSamples, int depthSamples,dReal scale, dReal offset, dReal thickness, int bWrap );
    return 0;
}

// lua : void OdeGeomHeightfieldDataSetBounds( dHeightfieldDataID d,dReal minHeight, dReal maxHeight ) [ from ode ]
static int l_OdeGeomHeightfieldDataSetBounds (lua_State *L) { PROFILE
    dGeomHeightfieldDataSetBounds( HEIGHTFIELDDATAID(1), GETNUMBER(2), GETNUMBER(3) );
    return 0;
}

// lua : void OdeGeomHeightfieldSetHeightfieldData( dGeomID g, dHeightfieldDataID d ) [ from ode ]
static int l_OdeGeomHeightfieldSetHeightfieldData (lua_State *L) { PROFILE
    dGeomHeightfieldSetHeightfieldData( GEOMID(1), HEIGHTFIELDDATAID(2) );
    return 0;
}

// lua : dHeightfieldDataID OdeGeomHeightfieldGetHeightfieldData( dGeomID g ) [ from ode ]
static int l_OdeGeomHeightfieldGetHeightfieldData (lua_State *L) { PROFILE
    PUSHUDATA( dGeomHeightfieldGetHeightfieldData( GEOMID(1) ) );
    return 1;
}

/* ************************************************************************ */
/* utility functions */
// lua : cp1x,cp1y,cp1z,cp2x,cp2y,cp2z OdeClosestLineSegmentPoints(const dVector3 a1, const dVector3 a2,const dVector3 b1, const dVector3 b2) [ from ode ]
static int l_OdeClosestLineSegmentPoints (lua_State *L) { PROFILE
    VEC3(1,a1);
    VEC3(4,a2);
    VEC3(7,b1);
    VEC3(10,b2);
    
    dVector3 cp1,cp2;
    dClosestLineSegmentPoints(a1,a2,b1,b2,cp1,cp2);
    
    PUSHVEC(cp1);
    PUSHVEC(cp2);
    return 6;
}


// lua : int OdeBoxTouchesBox(const dVector3 _p1, const dMatrix3 R1,const dVector3 side1, const dVector3 _p2,const dMatrix3 R2, const dVector3 side2) [ from ode ]
static int l_OdeBoxTouchesBox (lua_State *L) { PROFILE
    // TODO dBoxTouchesBox(const dVector3 _p1, const dMatrix3 R1,const dVector3 side1, const dVector3 _p2,const dMatrix3 R2, const dVector3 side2);
    return 0;
}

// lua : ax,ay,az, bx,by,bz OdeInfiniteAABB(dGeomID geom, dReal aabb[6]) [ from ode ]
static int l_OdeInfiniteAABB (lua_State *L) { PROFILE
    dReal aabb[6];
    dInfiniteAABB(GEOMID(1), aabb);
    PUSHVEC_(aabb,0);
    PUSHVEC_(aabb,3);
    return 6;
}


// lua : void OdeInitODE(void) [ from ode ]
static int l_OdeInitODE (lua_State *L) { PROFILE
    dInitODE();
    return 0;
}


// lua : void OdeCloseODE(void) [ from ode ]
static int l_OdeCloseODE (lua_State *L) { PROFILE
    dCloseODE();
    return 0;
}


// lua : int OdeCreateGeomClass(const dGeomClass *classptr) [ from ode ]
static int l_OdeCreateGeomClass (lua_State *L) { PROFILE
    // TODO dCreateGeomClass(const dGeomClass *classptr);
    return 0;
}


// lua : * OdeGeomGetClassData(dGeomID) [ from ode ]
static int l_OdeGeomGetClassData (lua_State *L) { PROFILE
    // TODO dGeomGetClassData(dGeomID);
    return 0;
}


// lua : dGeomID OdeCreateGeom(int classnum) [ from ode ]
static int l_OdeCreateGeom (lua_State *L) { PROFILE
    PUSHUDATA( dCreateGeom(GETINT(1)) );
    return 1;
}


// lua : dSpaceID OdeSimpleSpaceCreate(dSpaceID space) [ from ode ]
static int l_OdeSimpleSpaceCreate (lua_State *L) { PROFILE
    PUSHUDATA( dSimpleSpaceCreate(SPACEID(1)) );
    return 1;
}


// lua : dSpaceID OdeHashSpaceCreate(dSpaceID space) [ from ode ]
static int l_OdeHashSpaceCreate (lua_State *L) { PROFILE
    PUSHUDATA( dHashSpaceCreate(SPACEID(1)) );
    return 1;
}


// lua : dSpaceID OdeQuadTreeSpaceCreate(dSpaceID space, dVector3 Center, dVector3 Extents, int Depth) [ from ode ]
static int l_OdeQuadTreeSpaceCreate (lua_State *L) { PROFILE
    VEC3(2,v);
    VEC3(5,w);
    PUSHUDATA( dQuadTreeSpaceCreate(SPACEID(1), v,w, GETINT(8)) );
    return 1;
}


// lua : void OdeSpaceDestroy(dSpaceID) [ from ode ]
static int l_OdeSpaceDestroy (lua_State *L) { PROFILE
    dSpaceDestroy(SPACEID(1));
    return 0;
}


// lua : void OdeHashSpaceSetLevels(dSpaceID space, int minlevel, int maxlevel) [ from ode ]
static int l_OdeHashSpaceSetLevels (lua_State *L) { PROFILE
    dHashSpaceSetLevels(SPACEID(1), GETINT(2), GETINT(3));
    return 0;
}


// lua : minlevel,maxlevel OdeHashSpaceGetLevels(dSpaceID space, int *minlevel, int *maxlevel) [ from ode ]
static int l_OdeHashSpaceGetLevels (lua_State *L) { PROFILE
    int minlevel, maxlevel;
    dHashSpaceGetLevels(SPACEID(1), &minlevel, &maxlevel);
    PUSHNUMBER(minlevel);
    PUSHNUMBER(maxlevel);
    return 2;
}


// lua : void OdeSpaceSetCleanup(dSpaceID space, int mode) [ from ode ]
static int l_OdeSpaceSetCleanup (lua_State *L) { PROFILE
    dSpaceSetCleanup(SPACEID(1), GETINT(2));
    return 0;
}


// lua : int OdeSpaceGetCleanup(dSpaceID space) [ from ode ]
static int l_OdeSpaceGetCleanup (lua_State *L) { PROFILE
    PUSHNUMBER( dSpaceGetCleanup(SPACEID(1)) );
    return 1;
}


// lua : void OdeSpaceAdd(dSpaceID, dGeomID) [ from ode ]
static int l_OdeSpaceAdd (lua_State *L) { PROFILE
    dSpaceAdd(SPACEID(1), GEOMID(2));
    return 0;
}


// lua : void OdeSpaceRemove(dSpaceID, dGeomID) [ from ode ]
static int l_OdeSpaceRemove (lua_State *L) { PROFILE
    dSpaceRemove(SPACEID(1), GEOMID(2));
    return 0;
}


// lua : int OdeSpaceQuery(dSpaceID, dGeomID) [ from ode ]
static int l_OdeSpaceQuery (lua_State *L) { PROFILE
    PUSHNUMBER( dSpaceQuery(SPACEID(1), GEOMID(2)) );
    return 1;
}


// lua : void OdeSpaceClean(dSpaceID) [ from ode ]
static int l_OdeSpaceClean (lua_State *L) { PROFILE
    dSpaceClean(SPACEID(1));
    return 0;
}


// lua : int OdeSpaceGetNumGeoms(dSpaceID) [ from ode ]
static int l_OdeSpaceGetNumGeoms (lua_State *L) { PROFILE
    PUSHNUMBER( dSpaceGetNumGeoms(SPACEID(1)) );
    return 1;
}


// lua : dGeomID OdeSpaceGetGeom(dSpaceID, int i) [ from ode ]
static int l_OdeSpaceGetGeom (lua_State *L) { PROFILE
    PUSHUDATA( dSpaceGetGeom(SPACEID(1), GETINT(2)) );
    return 1;
}

/*
 * These dont make much sense now, but they will later when we add more
 * features.
 */


class cTriangleMeshRawData {
public:
    dVector3 *mVertexData;
    unsigned int *mIndicesData;
    unsigned int miTriangles;
    unsigned int miVertexes;
    unsigned int miIndices;
    
    cTriangleMeshRawData(cFIFO *f){
        assert(f && "f must not be 0");
        
        int trianglesize = 3 * 3 * sizeof(float);
        miTriangles = f->size() / trianglesize;
        miVertexes = miTriangles * 3;
        miIndices = miTriangles * 3;
        
        mVertexData = new dVector3[miVertexes];
        mIndicesData = new unsigned int[miIndices];
        
        unsigned int index = 0;
        while(f->size() > 0){
            mVertexData[index][0] = f->PopF();
            mVertexData[index][1] = f->PopF();
            mVertexData[index][2] = f->PopF();
            mVertexData[index][3] = 1.0f;
            mIndicesData[index] = index;
            ++index;
        }
    }

    void Print(){
        printf("DEBUG trimesh triangles=%d vertexes=%d indices=%d\n",miTriangles,miVertexes,miIndices);
        
        for(unsigned int i=0;i<miVertexes;++i){
            printf("Vertex[%f,%f,%f,%f]\n",mVertexData[i][0],mVertexData[i][1],mVertexData[i][2],mVertexData[i][3]);
        }
        for(unsigned int i=0;i<miIndices;i+=3){
            printf("Indices[%d,%d,%d]\n",mIndicesData[i],mIndicesData[i+1],mIndicesData[i+2]);
        }
        
        printf("dReal=%d dVector3=%d\n",sizeof(dReal),sizeof(dVector3));
    }
    
    ~cTriangleMeshRawData(){
        delete[] mVertexData;
        delete[] mIndicesData;
    }
};

// lua : cTriangleMeshRawData OdeTriMeshRawDataCreate(fifo)
static int l_OdeTriMeshRawDataCreate (lua_State *L) { PROFILE
    cFIFO *f = GETFIFO(1);
    if(f){
        PUSHUDATA( new cTriangleMeshRawData(f) );   
        return 1;
    } else return 0;
}


// lua : void OdeTriMeshRawDataDestroy(cTriangleMeshRawData)
static int l_OdeTriMeshRawDataDestroy (lua_State *L) { PROFILE
    cTriangleMeshRawData *p = TRIMESHRAWDATAID(1);
    if(p)delete p;
    return 0;
}

// lua : void OdeTriMeshRawDataPrint(cTriangleMeshRawData)
static int l_OdeTriMeshRawDataPrint (lua_State *L) { PROFILE
    cTriangleMeshRawData *p = TRIMESHRAWDATAID(1);
    if(p)p->Print();
    return 0;
}

// lua : dTriMeshDataID OdeGeomTriMeshDataCreate(void) [ from ode ]
static int l_OdeGeomTriMeshDataCreate (lua_State *L) { PROFILE
    PUSHUDATA( dGeomTriMeshDataCreate() );
    return 1;
}


// lua : void OdeGeomTriMeshDataDestroy(dTriMeshDataID g) [ from ode ]
static int l_OdeGeomTriMeshDataDestroy (lua_State *L) { PROFILE
    dGeomTriMeshDataDestroy(TRIMESHDATAID(1));
    return 0;
}


// lua : void OdeGeomTriMeshDataSet(dTriMeshDataID g, int data_id, void* in_data) [ from ode ]
static int l_OdeGeomTriMeshDataSet (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataSet(dTriMeshDataID g, int data_id, void* in_data);
    return 0;
}


// lua : void* OdeGeomTriMeshDataGet(dTriMeshDataID g, int data_id) [ from ode ]
static int l_OdeGeomTriMeshDataGet (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataGet(dTriMeshDataID g, int data_id);
    return 0;
}

// lua : void OdeGeomTriMeshSetLastTransform( dGeomID g, dMatrix4 last_trans ) [ from ode ]
static int l_OdeGeomTriMeshSetLastTransform (lua_State *L) { PROFILE
    // TODO dGeomTriMeshSetLastTransform( dGeomID g, dMatrix4 last_trans );
    return 0;
}


// lua : dReal* OdeGeomTriMeshGetLastTransform( dGeomID g ) [ from ode ]
static int l_OdeGeomTriMeshGetLastTransform (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetLastTransform( dGeomID g );
    return 0;
}

/*
 * Build TriMesh data with single precision used in vertex data .
 */
// lua : void OdeGeomTriMeshDataBuildSingle(dTriMeshDataID g,const void* Vertices, int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride) [ from ode ]
static int l_OdeGeomTriMeshDataBuildSingle (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataBuildSingle(dTriMeshDataID g,const void* Vertices, int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride);
    return 0;
}

/* same again with a normals array (used as trimesh-trimesh optimization) */
// lua : void OdeGeomTriMeshDataBuildSingle1(dTriMeshDataID g,const void* Vertices, int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride,const void* Normals) [ from ode ]
static int l_OdeGeomTriMeshDataBuildSingle1 (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataBuildSingle1(dTriMeshDataID g,const void* Vertices, int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride,const void* Normals);
    return 0;
}

/*
* Build TriMesh data with double pricision used in vertex data .
*/
// lua : void OdeGeomTriMeshDataBuildDouble(dTriMeshDataID g,const void* Vertices,  int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride) [ from ode ]
static int l_OdeGeomTriMeshDataBuildDouble (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataBuildDouble(dTriMeshDataID g,const void* Vertices,  int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride);
    return 0;
}

/* same again with a normals array (used as trimesh-trimesh optimization) */
// lua : void OdeGeomTriMeshDataBuildDouble1(dTriMeshDataID g,const void* Vertices,  int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride,const void* Normals) [ from ode ]
static int l_OdeGeomTriMeshDataBuildDouble1 (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataBuildDouble1(dTriMeshDataID g,const void* Vertices,  int VertexStride, int VertexCount,const void* Indices, int IndexCount, int TriStride,const void* Normals);
    return 0;
}

/*
 * Simple build. Single/double precision based on dSINGLE/dDOUBLE!

  void dGeomTriMeshDataBuildSingle1(dTriMeshDataID g,
                                  const void* Vertices, int VertexStride, int VertexCount,
                                  const void* Indices, int IndexCount, int TriStride,
                                  const void* Normals)
*/
// lua : void OdeGeomTriMeshDataBuildFromRaw(dTriMeshDataID g,cTriangleMeshRawData)
static int l_OdeGeomTriMeshDataBuildFromRaw (lua_State *L) { PROFILE
    cTriangleMeshRawData *p = TRIMESHRAWDATAID(2);
    if(p){
#ifdef dSINGLE
        dGeomTriMeshDataBuildSingle1(TRIMESHDATAID(1),
            p->mVertexData, sizeof(dVector3), p->miVertexes, 
            p->mIndicesData, p->miIndices, 3 * sizeof(unsigned int),
            0
        );
#else
        dGeomTriMeshDataBuildDouble1(TRIMESHDATAID(1),
            p->mVertexData, 3 * sizeof(dReal), p->miVertexes, 
            p->mIndicesData, p->miIndices, 3 * sizeof(unsigned int),
            0
        );
#endif
    }
    return 0;
}

/* same again with a normals array (used as trimesh-trimesh optimization) */
// lua : void OdeGeomTriMeshDataBuildSimple1(dTriMeshDataID g,const dReal* Vertices, int VertexCount,const int* Indices, int IndexCount,const int* Normals) [ from ode ]
static int l_OdeGeomTriMeshDataBuildSimple1 (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataBuildSimple1(dTriMeshDataID g,const dReal* Vertices, int VertexCount,const int* Indices, int IndexCount,const int* Normals);
    return 0;
}

/* Preprocess the trimesh data to remove mark unnecessary edges and vertices */
// lua : void OdeGeomTriMeshDataPreprocess(dTriMeshDataID g) [ from ode ]
static int l_OdeGeomTriMeshDataPreprocess (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataPreprocess(dTriMeshDataID g);
    return 0;
}

/* Get and set the internal preprocessed trimesh data buffer, for loading and saving */
// lua : void OdeGeomTriMeshDataGetBuffer(dTriMeshDataID g, unsigned char** buf, int* bufLen) [ from ode ]
static int l_OdeGeomTriMeshDataGetBuffer (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataGetBuffer(dTriMeshDataID g, unsigned char** buf, int* bufLen);
    return 0;
}


// lua : void OdeGeomTriMeshDataSetBuffer(dTriMeshDataID g, unsigned char* buf) [ from ode ]
static int l_OdeGeomTriMeshDataSetBuffer (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataSetBuffer(dTriMeshDataID g, unsigned char* buf);
    return 0;
}


// lua : void OdeGeomTriMeshSetCallback(dGeomID g, dTriCallback* Callback) [ from ode ]
static int l_OdeGeomTriMeshSetCallback (lua_State *L) { PROFILE
    // TODO dGeomTriMeshSetCallback(dGeomID g, dTriCallback* Callback);
    return 0;
}


// lua : dTriCallback* OdeGeomTriMeshGetCallback(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshGetCallback (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetCallback(dGeomID g);
    return 0;
}


// lua : void OdeGeomTriMeshSetArrayCallback(dGeomID g, dTriArrayCallback* ArrayCallback) [ from ode ]
static int l_OdeGeomTriMeshSetArrayCallback (lua_State *L) { PROFILE
    // TODO dGeomTriMeshSetArrayCallback(dGeomID g, dTriArrayCallback* ArrayCallback);
    return 0;
}


// lua : dTriArrayCallback* OdeGeomTriMeshGetArrayCallback(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshGetArrayCallback (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetArrayCallback(dGeomID g);
    return 0;
}


// lua : void OdeGeomTriMeshSetRayCallback(dGeomID g, dTriRayCallback* Callback) [ from ode ]
static int l_OdeGeomTriMeshSetRayCallback (lua_State *L) { PROFILE
    // TODO dGeomTriMeshSetRayCallback(dGeomID g, dTriRayCallback* Callback);
    return 0;
}


// lua : dTriRayCallback* OdeGeomTriMeshGetRayCallback(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshGetRayCallback (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetRayCallback(dGeomID g);
    return 0;
}

/*
 * Trimesh class
 * Construction. Callbacks are optional.
 */
// lua : dGeomID OdeCreateTriMesh(dSpaceID space, dTriMeshDataID Data)
// UNUSED, dTriCallback* Callback, dTriArrayCallback* ArrayCallback, dTriRayCallback* RayCallback) [ from ode ]
static int l_OdeCreateTriMesh (lua_State *L) { PROFILE
    PUSHUDATA( dCreateTriMesh(SPACEID(1), TRIMESHDATAID(2), 0,0,0) );
    // dTriCallback* Callback, dTriArrayCallback* ArrayCallback, dTriRayCallback* RayCallback);
    return 1;
}


// lua : void OdeGeomTriMeshSetData(dGeomID g, dTriMeshDataID Data) [ from ode ]
static int l_OdeGeomTriMeshSetData (lua_State *L) { PROFILE
    // TODO dGeomTriMeshSetData(dGeomID g, dTriMeshDataID Data);
    return 0;
}


// lua : dTriMeshDataID OdeGeomTriMeshGetData(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshGetData (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetData(dGeomID g);
    return 0;
}

// enable/disable/check temporal coherence
// lua : void OdeGeomTriMeshEnableTC(dGeomID g, int geomClass, int enable) [ from ode ]
static int l_OdeGeomTriMeshEnableTC (lua_State *L) { PROFILE
    // TODO dGeomTriMeshEnableTC(dGeomID g, int geomClass, int enable);
    return 0;
}


// lua : int OdeGeomTriMeshIsTCEnabled(dGeomID g, int geomClass) [ from ode ]
static int l_OdeGeomTriMeshIsTCEnabled (lua_State *L) { PROFILE
    // TODO dGeomTriMeshIsTCEnabled(dGeomID g, int geomClass);
    return 0;
}

/*
 * 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.
 * We should be able to do this automagically.
 */
// lua : void OdeGeomTriMeshClearTCCache(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshClearTCCache (lua_State *L) { PROFILE
    // TODO dGeomTriMeshClearTCCache(dGeomID g);
    return 0;
}

/*
 * returns the TriMeshDataID
 */
// lua : dTriMeshDataID OdeGeomTriMeshGetTriMeshDataID(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshGetTriMeshDataID (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetTriMeshDataID(dGeomID g);
    return 0;
}

/*
 * Gets a triangle.
 */
// lua : void OdeGeomTriMeshGetTriangle(dGeomID g, int Index, dVector3* v0, dVector3* v1, dVector3* v2) [ from ode ]
static int l_OdeGeomTriMeshGetTriangle (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetTriangle(dGeomID g, int Index, dVector3* v0, dVector3* v1, dVector3* v2);
    return 0;
}

/*
 * Gets the point on the requested triangle and the given barycentric
 * coordinates.
 */
// lua : void OdeGeomTriMeshGetPoint(dGeomID g, int Index, dReal u, dReal v, dVector3 Out) [ from ode ]
static int l_OdeGeomTriMeshGetPoint (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetPoint(dGeomID g, int Index, dReal u, dReal v, dVector3 Out);
    return 0;
}

// lua : int OdeGeomTriMeshGetTriangleCount(dGeomID g) [ from ode ]
static int l_OdeGeomTriMeshGetTriangleCount (lua_State *L) { PROFILE
    // TODO dGeomTriMeshGetTriangleCount(dGeomID g);
    return 0;
}


// lua : void OdeGeomTriMeshDataUpdate(dTriMeshDataID g) [ from ode ]
static int l_OdeGeomTriMeshDataUpdate (lua_State *L) { PROFILE
    // TODO dGeomTriMeshDataUpdate(dTriMeshDataID g);
    return 0;
}


// lua : udata OdeMassCreate()
static int l_OdeMassCreate (lua_State *L) { PROFILE
    PUSHUDATA( new dMass );
    return 1;
}

// lua : void OdeMassDestroy(udata)
static int l_OdeMassDestroy (lua_State *L) { PROFILE
    dMass *p = MASSID(1);
    if(p)delete p;
    return 0;
}



// lua : int OdeMassCheck(const dMass *m) [ from ode ]
static int l_OdeMassCheck (lua_State *L) { PROFILE
    PUSHNUMBER( dMassCheck(MASSID(1)) );
    return 1;
}


// lua : void OdeMassSetZero(dMass *) [ from ode ]
static int l_OdeMassSetZero (lua_State *L) { PROFILE
    dMassSetZero(MASSID(1));
    return 0;
}


// lua : void OdeMassSetParameters(dMass *, dReal themass,dReal cgx, dReal cgy, dReal cgz,dReal I11, dReal I22, dReal I33,dReal I12, dReal I13, dReal I23) [ from ode ]
static int l_OdeMassSetParameters (lua_State *L) { PROFILE
    // TODO I.. parts could be a problem due to axis exchangement dMassSetParameters(MASSID(1), GETNUMBER(2), GETVEC(3), GETLIST3(3), GETLIST3(3));
    return 0;
}


// lua : void OdeMassSetSphere(dMass *, dReal density, dReal radius) [ from ode ]
static int l_OdeMassSetSphere (lua_State *L) { PROFILE
    dMassSetSphere(MASSID(1), GETNUMBER(2), GETNUMBER(3));
    return 0;
}


// lua : void OdeMassSetSphereTotal(dMass *, dReal total_mass, dReal radius) [ from ode ]
static int l_OdeMassSetSphereTotal (lua_State *L) { PROFILE
    dMassSetSphereTotal(MASSID(1), GETNUMBER(2), GETNUMBER(3));
    return 0;
}


// lua : void OdeMassSetCapsule(dMass *, dReal density, int direction,dReal radius, dReal length) [ from ode ]
static int l_OdeMassSetCapsule (lua_State *L) { PROFILE
    dMassSetCapsule(MASSID(1), GETNUMBER(2), GETINT(3), GETNUMBER(4), GETNUMBER(5));
    return 0;
}


// lua : void OdeMassSetCapsuleTotal(dMass *, dReal total_mass, int direction,dReal radius, dReal length) [ from ode ]
static int l_OdeMassSetCapsuleTotal (lua_State *L) { PROFILE
    dMassSetCapsuleTotal(MASSID(1), GETNUMBER(2), GETINT(3), GETNUMBER(4), GETNUMBER(5));
    return 0;
}


// lua : void OdeMassSetCylinder(dMass *, dReal density, int direction,dReal radius, dReal length) [ from ode ]
static int l_OdeMassSetCylinder (lua_State *L) { PROFILE
    dMassSetCylinder(MASSID(1), GETNUMBER(2), GETINT(3), GETNUMBER(4), GETNUMBER(5));
    return 0;
}


// lua : void OdeMassSetCylinderTotal(dMass *, dReal total_mass, int direction,dReal radius, dReal length) [ from ode ]
static int l_OdeMassSetCylinderTotal (lua_State *L) { PROFILE
    dMassSetCylinderTotal(MASSID(1), GETNUMBER(2), GETINT(3), GETNUMBER(4), GETNUMBER(5));
    return 0;
}


// lua : void OdeMassSetBox(dMass *, dReal density,dReal lx, dReal ly, dReal lz) [ from ode ]
static int l_OdeMassSetBox (lua_State *L) { PROFILE
    dMassSetBox(MASSID(1), GETNUMBER(2), GETNUMBER(3), GETNUMBER(4), GETNUMBER(5));
    return 0;
}


// lua : void OdeMassSetBoxTotal(dMass *, dReal total_mass,dReal lx, dReal ly, dReal lz) [ from ode ]
static int l_OdeMassSetBoxTotal (lua_State *L) { PROFILE
    dMassSetBoxTotal(MASSID(1), GETNUMBER(2), GETNUMBER(3), GETNUMBER(4), GETNUMBER(5));
    return 0;
}


// lua : void OdeMassSetTrimesh(dMass *, dReal density, dGeomID g) [ from ode ]
static int l_OdeMassSetTrimesh (lua_State *L) { PROFILE
    dMassSetTrimesh(MASSID(1), GETNUMBER(2), GEOMID(3));
    return 0;
}


// lua : void OdeMassAdjust(dMass *, dReal newmass) [ from ode ]
static int l_OdeMassAdjust (lua_State *L) { PROFILE
    dMassAdjust(MASSID(1), GETNUMBER(2));
    return 0;
}


// lua : void OdeMassTranslate(dMass *, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeMassTranslate (lua_State *L) { PROFILE
    dMassTranslate(MASSID(1), GETVEC(2));
    return 0;
}


// lua : void OdeMassAdd(dMass *a, const dMass *b) [ from ode ]
static int l_OdeMassAdd (lua_State *L) { PROFILE
    dMassAdd(MASSID(1), MASSID(2));
    return 0;
}

// lua : udata l_OdeWorldCreate() [ from ode ]
static int l_OdeWorldCreate (lua_State *L) { PROFILE
    PUSHUDATA( dWorldCreate() );
    return 1;
}

// lua : void OdeWorldDestroy(dWorldID world) [ from ode ]
static int l_OdeWorldDestroy (lua_State *L) { PROFILE
    dWorldDestroy(WORLDID(1));
    return 0;
}

// lua : void OdeWorldSetGravity(dWorldID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeWorldSetGravity (lua_State *L) { PROFILE
    dWorldSetGravity(WORLDID(1), GETVEC(2));
    return 0;
}

// lua : void OdeWorldGetGravity(dWorldID, dVector3 gravity) [ from ode ]
static int l_OdeWorldGetGravity (lua_State *L) { PROFILE
    dVector3 gravity;
    dWorldGetGravity(WORLDID(1), gravity);
    PUSHVEC(gravity);
    return 3;
}

// lua : void OdeWorldSetERP(dWorldID, dReal erp) [ from ode ]
static int l_OdeWorldSetERP (lua_State *L) { PROFILE
    dWorldSetERP(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetERP(dWorldID) [ from ode ]
static int l_OdeWorldGetERP (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetERP(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetCFM(dWorldID, dReal cfm) [ from ode ]
static int l_OdeWorldSetCFM (lua_State *L) { PROFILE
    dWorldSetCFM(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetCFM(dWorldID) [ from ode ]
static int l_OdeWorldGetCFM (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetCFM(WORLDID(1)));
    return 1;
}

// lua : void OdeWorldStep(dWorldID, dReal stepsize) [ from ode ]
static int l_OdeWorldStep (lua_State *L) { PROFILE
    dWorldStep(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : void OdeWorldImpulseToForce(dWorldID, dReal stepsize,dReal ix, dReal iy, dReal iz, dVector3 force) [ from ode ]
static int l_OdeWorldImpulseToForce (lua_State *L) { PROFILE
    dVector3 force;
    dWorldImpulseToForce(WORLDID(1), GETNUMBER(2), GETVEC(3), force);
    PUSHVEC(force);
    return 3;
}

// lua : void OdeWorldQuickStep(dWorldID w, dReal stepsize) [ from ode ]
static int l_OdeWorldQuickStep (lua_State *L) { PROFILE
    dWorldQuickStep(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : void OdeWorldSetQuickStepNumIterations(dWorldID, int num) [ from ode ]
static int l_OdeWorldSetQuickStepNumIterations (lua_State *L) { PROFILE
    dWorldSetQuickStepNumIterations(WORLDID(1), GETINT(2));
    return 0;
}

// lua : int OdeWorldGetQuickStepNumIterations(dWorldID) [ from ode ]
static int l_OdeWorldGetQuickStepNumIterations (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetQuickStepNumIterations(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetQuickStepW(dWorldID, dReal over_relaxation) [ from ode ]
static int l_OdeWorldSetQuickStepW (lua_State *L) { PROFILE
    dWorldSetQuickStepW(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetQuickStepW(dWorldID) [ from ode ]
static int l_OdeWorldGetQuickStepW (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetQuickStepW(WORLDID(1)) );
    return 1;
}

/* World contact parameter functions */

// lua : void OdeWorldSetContactMaxCorrectingVel(dWorldID, dReal vel) [ from ode ]
static int l_OdeWorldSetContactMaxCorrectingVel (lua_State *L) { PROFILE
    dWorldSetContactMaxCorrectingVel(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetContactMaxCorrectingVel(dWorldID) [ from ode ]
static int l_OdeWorldGetContactMaxCorrectingVel (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetContactMaxCorrectingVel(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetContactSurfaceLayer(dWorldID, dReal depth) [ from ode ]
static int l_OdeWorldSetContactSurfaceLayer (lua_State *L) { PROFILE
    dWorldSetContactSurfaceLayer(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetContactSurfaceLayer(dWorldID) [ from ode ]
static int l_OdeWorldGetContactSurfaceLayer (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetContactSurfaceLayer(WORLDID(1)) );
    return 1;
}

/* StepFast1 functions */

// lua : void OdeWorldStepFast1(dWorldID, dReal stepsize, int maxiterations) [ from ode ]
static int l_OdeWorldStepFast1 (lua_State *L) { PROFILE
    dWorldStepFast1(WORLDID(1), GETNUMBER(2), GETINT(3));
    return 0;
}

// lua : void OdeWorldSetAutoEnableDepthSF1(dWorldID, int autoEnableDepth) [ from ode ]
static int l_OdeWorldSetAutoEnableDepthSF1 (lua_State *L) { PROFILE
    dWorldSetAutoEnableDepthSF1(WORLDID(1), GETINT(2));
    return 0;
}

// lua : int OdeWorldGetAutoEnableDepthSF1(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoEnableDepthSF1 (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoEnableDepthSF1(WORLDID(1)) );
    return 1;
}

// lua : dReal OdeWorldGetAutoDisableLinearThreshold(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableLinearThreshold (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoDisableLinearThreshold(WORLDID(1)) );
    return 0;
}

// lua : void OdeWorldSetAutoDisableLinearThreshold(dWorldID, dReal linear_threshold) [ from ode ]
static int l_OdeWorldSetAutoDisableLinearThreshold (lua_State *L) { PROFILE
    dWorldSetAutoDisableLinearThreshold(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetAutoDisableAngularThreshold(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableAngularThreshold (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoDisableAngularThreshold(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableAngularThreshold(dWorldID, dReal angular_threshold) [ from ode ]
static int l_OdeWorldSetAutoDisableAngularThreshold (lua_State *L) { PROFILE
    dWorldSetAutoDisableAngularThreshold(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetAutoDisableLinearAverageThreshold(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableLinearAverageThreshold (lua_State *L) { PROFILE
    // TODO PUSHNUMBER( dWorldGetAutoDisableLinearAverageThreshold(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableLinearAverageThreshold(dWorldID, dReal linear_average_threshold) [ from ode ]
static int l_OdeWorldSetAutoDisableLinearAverageThreshold (lua_State *L) { PROFILE
    // TODO dWorldSetAutoDisableLinearAverageThreshold(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeWorldGetAutoDisableAngularAverageThreshold(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableAngularAverageThreshold (lua_State *L) { PROFILE
    // TODO PUSHNUMBER( dWorldGetAutoDisableAngularAverageThreshold(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableAngularAverageThreshold(dWorldID, dReal angular_average_threshold) [ from ode ]
static int l_OdeWorldSetAutoDisableAngularAverageThreshold (lua_State *L) { PROFILE
    // TODO dWorldSetAutoDisableAngularAverageThreshold(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : int OdeWorldGetAutoDisableAverageSamplesCount(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableAverageSamplesCount (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoDisableAverageSamplesCount(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableAverageSamplesCount(dWorldID, unsigned int average_samples_count ) [ from ode ]
static int l_OdeWorldSetAutoDisableAverageSamplesCount (lua_State *L) { PROFILE
    dWorldSetAutoDisableAverageSamplesCount(WORLDID(1), GETUINT(2));
    return 0;
}

// lua : int OdeWorldGetAutoDisableSteps(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableSteps (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoDisableSteps(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableSteps(dWorldID, int steps) [ from ode ]
static int l_OdeWorldSetAutoDisableSteps (lua_State *L) { PROFILE
    dWorldSetAutoDisableSteps(WORLDID(1), GETINT(2));
    return 0;
}

// lua : dReal OdeWorldGetAutoDisableTime(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableTime (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoDisableTime(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableTime(dWorldID, dReal time) [ from ode ]
static int l_OdeWorldSetAutoDisableTime (lua_State *L) { PROFILE
    dWorldSetAutoDisableTime(WORLDID(1), GETNUMBER(2));
    return 0;
}

// lua : int OdeWorldGetAutoDisableFlag(dWorldID) [ from ode ]
static int l_OdeWorldGetAutoDisableFlag (lua_State *L) { PROFILE
    PUSHNUMBER( dWorldGetAutoDisableFlag(WORLDID(1)) );
    return 1;
}

// lua : void OdeWorldSetAutoDisableFlag(dWorldID, int do_auto_disable) [ from ode ]
static int l_OdeWorldSetAutoDisableFlag (lua_State *L) { PROFILE
    dWorldSetAutoDisableFlag(WORLDID(1), GETINT(2));
    return 0;
}

// lua : dReal OdeBodyGetAutoDisableLinearThreshold(dBodyID) [ from ode ]
static int l_OdeBodyGetAutoDisableLinearThreshold (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetAutoDisableLinearThreshold(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetAutoDisableLinearThreshold(dBodyID, dReal linear_average_threshold) [ from ode ]
static int l_OdeBodySetAutoDisableLinearThreshold (lua_State *L) { PROFILE
    dBodySetAutoDisableLinearThreshold(BODYID(1), GETNUMBER(2));
    return 0;
}

// lua : dReal OdeBodyGetAutoDisableAngularThreshold(dBodyID) [ from ode ]
static int l_OdeBodyGetAutoDisableAngularThreshold (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetAutoDisableAngularThreshold(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetAutoDisableAngularThreshold(dBodyID, dReal angular_average_threshold) [ from ode ]
static int l_OdeBodySetAutoDisableAngularThreshold (lua_State *L) { PROFILE
    dBodySetAutoDisableAngularThreshold(BODYID(1), GETNUMBER(2));
    return 0;
}

// lua : int OdeBodyGetAutoDisableAverageSamplesCount(dBodyID) [ from ode ]
static int l_OdeBodyGetAutoDisableAverageSamplesCount (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetAutoDisableAverageSamplesCount(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetAutoDisableAverageSamplesCount(dBodyID, unsigned int average_samples_count) [ from ode ]
static int l_OdeBodySetAutoDisableAverageSamplesCount (lua_State *L) { PROFILE
    dBodySetAutoDisableAverageSamplesCount(BODYID(1), GETUINT(2));
    return 0;
}

// lua : int OdeBodyGetAutoDisableSteps(dBodyID) [ from ode ]
static int l_OdeBodyGetAutoDisableSteps (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetAutoDisableSteps(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetAutoDisableSteps(dBodyID, int steps) [ from ode ]
static int l_OdeBodySetAutoDisableSteps (lua_State *L) { PROFILE
    dBodySetAutoDisableSteps(BODYID(1), GETINT(2));
    return 0;
}

// lua : dReal OdeBodyGetAutoDisableTime(dBodyID) [ from ode ]
static int l_OdeBodyGetAutoDisableTime (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetAutoDisableTime(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetAutoDisableTime(dBodyID, dReal time) [ from ode ]
static int l_OdeBodySetAutoDisableTime (lua_State *L) { PROFILE
    dBodySetAutoDisableTime(BODYID(1), GETNUMBER(2));
    return 0;
}

// lua : int OdeBodyGetAutoDisableFlag(dBodyID) [ from ode ]
static int l_OdeBodyGetAutoDisableFlag (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetAutoDisableFlag(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetAutoDisableFlag(dBodyID, int do_auto_disable) [ from ode ]
static int l_OdeBodySetAutoDisableFlag (lua_State *L) { PROFILE
    dBodySetAutoDisableFlag(BODYID(1), GETINT(2));
    return 0;
}

// lua : void OdeBodySetAutoDisableDefaults(dBodyID) [ from ode ]
static int l_OdeBodySetAutoDisableDefaults (lua_State *L) { PROFILE
    dBodySetAutoDisableDefaults(BODYID(1));
    return 0;
}

// lua : dWorldID OdeBodyGetWorld(dBodyID) [ from ode ]
static int l_OdeBodyGetWorld (lua_State *L) { PROFILE
    PUSHUDATA( dBodyGetWorld(BODYID(1)) );
    return 1;
}

// lua : dBodyID OdeBodyCreate(dWorldID) [ from ode ]
static int l_OdeBodyCreate (lua_State *L) { PROFILE
    PUSHUDATA( dBodyCreate(WORLDID(1)) );
    return 1;
}

// lua : void OdeBodyDestroy(dBodyID) [ from ode ]
static int l_OdeBodyDestroy (lua_State *L) { PROFILE
    dBodyDestroy(BODYID(1));
    return 0;
}

// lua : void OdeBodySetData(dBodyID, void *data) [ from ode ]
static int l_OdeBodySetData (lua_State *L) { PROFILE
    dBodySetData(BODYID(1), GETUDATA(2));
    return 0;
}

// lua : void OdeBodyGetData(dBodyID) [ from ode ]
static int l_OdeBodyGetData (lua_State *L) { PROFILE
    PUSHUDATA( dBodyGetData(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetPosition(dBodyID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeBodySetPosition (lua_State *L) { PROFILE
    dBodySetPosition(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodySetQuaternion(dBodyID, const dQuaternion q) [ from ode ]
static int l_OdeBodySetQuaternion (lua_State *L) { PROFILE
    QUAT4(2,q);
    dBodySetQuaternion(BODYID(1), q);
    return 0;
}

// lua : void OdeBodySetLinearVel(dBodyID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeBodySetLinearVel (lua_State *L) { PROFILE
    dBodySetLinearVel(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodySetAngularVel(dBodyID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeBodySetAngularVel (lua_State *L) { PROFILE
    dBodySetAngularVel(BODYID(1), GETVEC(2));
    return 0;
}

// lua : x,y,z OdeBodyGetPosition(dBodyID) [ from ode ]
static int l_OdeBodyGetPosition (lua_State *L) { PROFILE
    const dReal *x = dBodyGetPosition(BODYID(1));
    PUSHVEC(x);
    return 3;
}


// lua : w,x,y,z OdeBodyGetQuaternion(dBodyID) [ from ode ]
static int l_OdeBodyGetQuaternion (lua_State *L) { PROFILE
    const dReal *x = dBodyGetQuaternion(BODYID(1));
    PUSHQUAT(x);
    return 4;
}

// lua : * OdeBodyGetLinearVel(dBodyID) [ from ode ]
static int l_OdeBodyGetLinearVel (lua_State *L) { PROFILE
    const dReal *x = dBodyGetLinearVel(BODYID(1));
    PUSHVEC(x);
    return 3;
}

// lua : * OdeBodyGetAngularVel(dBodyID) [ from ode ]
static int l_OdeBodyGetAngularVel (lua_State *L) { PROFILE
    const dReal *x = dBodyGetAngularVel(BODYID(1));
    PUSHVEC(x);
    return 3;   
}

// lua : void OdeBodySetMass(dBodyID, const dMass *mass) [ from ode ]
static int l_OdeBodySetMass (lua_State *L) { PROFILE
    dBodySetMass(BODYID(1), MASSID(2));
    return 0;
}

// lua : void OdeBodyGetMass(dBodyID, dMass *mass) [ from ode ]
static int l_OdeBodyGetMass (lua_State *L) { PROFILE
    dBodyGetMass(BODYID(1), MASSID(2));
    return 0;
}

// lua : void OdeBodyAddForce(dBodyID, dReal fx, dReal fy, dReal fz) [ from ode ]
static int l_OdeBodyAddForce (lua_State *L) { PROFILE
    dBodyAddForce(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodyAddTorque(dBodyID, dReal fx, dReal fy, dReal fz) [ from ode ]
static int l_OdeBodyAddTorque (lua_State *L) { PROFILE
    dBodyAddTorque(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodyAddRelForce(dBodyID, dReal fx, dReal fy, dReal fz) [ from ode ]
static int l_OdeBodyAddRelForce (lua_State *L) { PROFILE
    dBodyAddRelForce(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodyAddRelTorque(dBodyID, dReal fx, dReal fy, dReal fz) [ from ode ]
static int l_OdeBodyAddRelTorque (lua_State *L) { PROFILE
    dBodyAddRelTorque(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodyAddForceAtPos(dBodyID, dReal fx, dReal fy, dReal fz,dReal px, dReal py, dReal pz) [ from ode ]
static int l_OdeBodyAddForceAtPos (lua_State *L) { PROFILE
    dBodyAddForceAtPos(BODYID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : void OdeBodyAddForceAtRelPos(dBodyID, dReal fx, dReal fy, dReal fz,dReal px, dReal py, dReal pz) [ from ode ]
static int l_OdeBodyAddForceAtRelPos (lua_State *L) { PROFILE
    dBodyAddForceAtRelPos(BODYID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : void OdeBodyAddRelForceAtPos(dBodyID, dReal fx, dReal fy, dReal fz,dReal px, dReal py, dReal pz) [ from ode ]
static int l_OdeBodyAddRelForceAtPos (lua_State *L) { PROFILE
    dBodyAddRelForceAtPos(BODYID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : void OdeBodyAddRelForceAtRelPos(dBodyID, dReal fx, dReal fy, dReal fz,dReal px, dReal py, dReal pz) [ from ode ]
static int l_OdeBodyAddRelForceAtRelPos (lua_State *L) { PROFILE
    dBodyAddRelForceAtRelPos(BODYID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : fx,fy,fz OdeBodyGetForce(dBodyID) [ from ode ]
static int l_OdeBodyGetForce (lua_State *L) { PROFILE
    const dReal *x = dBodyGetForce(BODYID(1));
    PUSHVEC(x);
    return 3;   
}

// lua : x,y,z OdeBodyGetTorque(dBodyID) [ from ode ]
static int l_OdeBodyGetTorque (lua_State *L) { PROFILE
    const dReal *x = dBodyGetTorque(BODYID(1));
    PUSHVEC(x);
    return 3;
}

// lua : void OdeBodySetForce(dBodyID b, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeBodySetForce (lua_State *L) { PROFILE
    dBodySetForce(BODYID(1), GETVEC(2));
    return 0;
}

// lua : void OdeBodySetTorque(dBodyID b, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeBodySetTorque (lua_State *L) { PROFILE
    dBodySetTorque(BODYID(1), GETVEC(2));
    return 0;
}

// lua : x,y,z OdeBodyGetRelPointPos(dBodyID, dReal px, dReal py, dReal pz,dVector3 result) [ from ode ]
static int l_OdeBodyGetRelPointPos (lua_State *L) { PROFILE
    dVector3 result;
    dBodyGetRelPointPos(BODYID(1), GETVEC(2),result);
    PUSHVEC(result);
    return 3;
}

// lua : x,y,z OdeBodyGetRelPointVel(dBodyID, dReal px, dReal py, dReal pz,dVector3 result) [ from ode ]
static int l_OdeBodyGetRelPointVel (lua_State *L) { PROFILE
    dVector3 result;
    dBodyGetRelPointVel(BODYID(1), GETVEC(2),result);
    PUSHVEC(result);
    return 3;
}

// lua : x,y,z OdeBodyGetPointVel(dBodyID, dReal px, dReal py, dReal pz,dVector3 result) [ from ode ]
static int l_OdeBodyGetPointVel (lua_State *L) { PROFILE
    dVector3 result;
    dBodyGetPointVel(BODYID(1), GETVEC(2),result);
    PUSHVEC(result);
    return 3;
}

// lua : x,y,z OdeBodyGetPosRelPoint(dBodyID, dReal px, dReal py, dReal pz,dVector3 result) [ from ode ]
static int l_OdeBodyGetPosRelPoint (lua_State *L) { PROFILE
    dVector3 result;
    dBodyGetPosRelPoint(BODYID(1), GETVEC(2),result);
    PUSHVEC(result);
    return 3;
}

// lua : x,y,z OdeBodyVectorToWorld(dBodyID, dReal px, dReal py, dReal pz,dVector3 result) [ from ode ]
static int l_OdeBodyVectorToWorld (lua_State *L) { PROFILE
    dVector3 result;
    dBodyVectorToWorld(BODYID(1), GETVEC(2),result);
    PUSHVEC(result);
    return 3;
}

// lua : x,y,z OdeBodyVectorFromWorld(dBodyID, dReal px, dReal py, dReal pz,dVector3 result) [ from ode ]
static int l_OdeBodyVectorFromWorld (lua_State *L) { PROFILE
    dVector3 result;
    dBodyVectorFromWorld(BODYID(1), GETVEC(2),result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeBodySetFiniteRotationMode(dBodyID, int mode) [ from ode ]
static int l_OdeBodySetFiniteRotationMode (lua_State *L) { PROFILE
    dBodySetFiniteRotationMode(BODYID(1), GETINT(2));
    return 0;
}

// lua : void OdeBodySetFiniteRotationAxis(dBodyID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeBodySetFiniteRotationAxis (lua_State *L) { PROFILE
    dBodySetFiniteRotationAxis(BODYID(1), GETVEC(2));
    return 0;
}

// lua : int OdeBodyGetFiniteRotationMode(dBodyID) [ from ode ]
static int l_OdeBodyGetFiniteRotationMode (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetFiniteRotationMode(BODYID(1)) );
    return 1;
}

// lua : x,y,z OdeBodyGetFiniteRotationAxis(dBodyID, dVector3 result) [ from ode ]
static int l_OdeBodyGetFiniteRotationAxis (lua_State *L) { PROFILE
    dVector3 result;
    dBodyGetFiniteRotationAxis(BODYID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : int OdeBodyGetNumJoints(dBodyID b) [ from ode ]
static int l_OdeBodyGetNumJoints (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetNumJoints(BODYID(1)) );
    return 1;
}

// lua : dJointID OdeBodyGetJoint(dBodyID, int index) [ from ode ]
static int l_OdeBodyGetJoint (lua_State *L) { PROFILE
    PUSHUDATA( dBodyGetJoint(BODYID(1), GETINT(2)) );
    return 0;
}

// lua : void OdeBodyEnable(dBodyID) [ from ode ]
static int l_OdeBodyEnable (lua_State *L) { PROFILE
    dBodyEnable(BODYID(1));
    return 0;
}

// lua : void OdeBodyDisable(dBodyID) [ from ode ]
static int l_OdeBodyDisable (lua_State *L) { PROFILE
    dBodyDisable(BODYID(1));
    return 0;
}

// lua : int OdeBodyIsEnabled(dBodyID) [ from ode ]
static int l_OdeBodyIsEnabled (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyIsEnabled(BODYID(1)) );
    return 1;
}

// lua : void OdeBodySetGravityMode(dBodyID b, int mode) [ from ode ]
static int l_OdeBodySetGravityMode (lua_State *L) { PROFILE
    dBodySetGravityMode(BODYID(1), GETINT(2));
    return 0;
}

// lua : int OdeBodyGetGravityMode(dBodyID b) [ from ode ]
static int l_OdeBodyGetGravityMode (lua_State *L) { PROFILE
    PUSHNUMBER( dBodyGetGravityMode(BODYID(1)) );
    return 1;
}

// lua : dJointID OdeJointCreateBall(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateBall (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateBall(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateHinge(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateHinge (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateHinge(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateSlider(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateSlider (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateSlider(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateContact(dWorldID, dJointGroupID, const dContact *) [ from ode ]
static int l_OdeJointCreateContact (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateContact(WORLDID(1), JOINTGROUPID(2), CONTACTID(3)) );
    return 1;
}

// lua : dJointID OdeJointCreateHinge2(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateHinge2 (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateHinge2(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateUniversal(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateUniversal (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateUniversal(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreatePR(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreatePR (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreatePR(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateFixed(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateFixed (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateFixed(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}


// lua : dJointID OdeJointCreateNull(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateNull (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateNull(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateAMotor(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateAMotor (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateAMotor(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreateLMotor(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreateLMotor (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreateLMotor(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : dJointID OdeJointCreatePlane2D(dWorldID, dJointGroupID) [ from ode ]
static int l_OdeJointCreatePlane2D (lua_State *L) { PROFILE
    PUSHUDATA( dJointCreatePlane2D(WORLDID(1), JOINTGROUPID(2)) );
    return 1;
}

// lua : void OdeJointDestroy(dJointID) [ from ode ]
static int l_OdeJointDestroy (lua_State *L) { PROFILE
    dJointDestroy(JOINTID(1));
    return 0;
}

// lua : dJointGroupID OdeJointGroupCreate(int max_size) [ from ode ]
static int l_OdeJointGroupCreate (lua_State *L) { PROFILE
    PUSHUDATA( dJointGroupCreate(8) );
    return 1;
}

// lua : void OdeJointGroupDestroy(dJointGroupID) [ from ode ]
static int l_OdeJointGroupDestroy (lua_State *L) { PROFILE
    dJointGroupDestroy(JOINTGROUPID(1));
    return 0;
}

// lua : void OdeJointGroupEmpty(dJointGroupID) [ from ode ]
static int l_OdeJointGroupEmpty (lua_State *L) { PROFILE
    dJointGroupEmpty(JOINTGROUPID(1));
    return 0;
}

// lua : void OdeJointAttach(dJointID, dBodyID body1, dBodyID body2) [ from ode ]
static int l_OdeJointAttach (lua_State *L) { PROFILE
    dJointAttach(JOINTID(1), BODYID(2), BODYID(3));
    return 0;
}

// lua : void OdeJointSetData(dJointID, void *data) [ from ode ]
static int l_OdeJointSetData (lua_State *L) { PROFILE
    dJointSetData(JOINTID(1), GETUDATA(2));
    return 0;
}

// lua : void OdedJointGetData(dJointID) [ from ode ]
static int l_OdedJointGetData (lua_State *L) { PROFILE
    PUSHUDATA( dJointGetData(JOINTID(1)) );
    return 1;
}

// lua : int OdeJointGetType(dJointID) [ from ode ]
static int l_OdeJointGetType (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetType(JOINTID(1)) );
    return 0;
}

// lua : dBodyID OdeJointGetBody(dJointID, int index) [ from ode ]
static int l_OdeJointGetBody (lua_State *L) { PROFILE
    PUSHUDATA( dJointGetBody(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : void OdeJointFeedbackCreate(udata)
static int l_OdeJointFeedbackDestroy (lua_State *L) { PROFILE
    dJointFeedback *p = JOINTFEEDBACKID(1);
    if(p)delete p;  
    return 0;
}

// lua : udata OdeJointFeedbackCreate()
static int l_OdeJointFeedbackCreate (lua_State *L) { PROFILE
    PUSHUDATA( new dJointFeedback );
    return 1;
}

// lua : void OdeJointSetFeedback(dJointID, dJointFeedback *) [ from ode ]
static int l_OdeJointSetFeedback (lua_State *L) { PROFILE
    dJointSetFeedback(JOINTID(1), JOINTFEEDBACKID(2));
    return 0;
}

// lua : dJointFeedback OdeJointGetFeedback(dJointID) [ from ode ]
static int l_OdeJointGetFeedback (lua_State *L) { PROFILE
    PUSHUDATA(dJointGetFeedback(JOINTID(1)));
    return 1;
}

// lua : void OdeJointSetBallAnchor(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetBallAnchor (lua_State *L) { PROFILE
    dJointSetBallAnchor(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetBallAnchor2(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetBallAnchor2 (lua_State *L) { PROFILE
    dJointSetBallAnchor2(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetHingeAnchor(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetHingeAnchor (lua_State *L) { PROFILE
    dJointSetHingeAnchor(JOINTID(1), GETVEC(2));
    return 0;
}


// lua : void OdeJointSetHingeAnchorDelta(dJointID, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az) [ from ode ]
static int l_OdeJointSetHingeAnchorDelta (lua_State *L) { PROFILE
    dJointSetHingeAnchorDelta(JOINTID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : void OdeJointSetHingeAxis(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetHingeAxis (lua_State *L) { PROFILE
    dJointSetHingeAxis(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetHingeParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetHingeParam (lua_State *L) { PROFILE
    dJointSetHingeParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointAddHingeTorque(dJointID joint, dReal torque) [ from ode ]
static int l_OdeJointAddHingeTorque (lua_State *L) { PROFILE
    dJointAddHingeTorque(JOINTID(1), GETNUMBER(2));
    return 0;
}

// lua : void OdeJointSetSliderAxis(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetSliderAxis (lua_State *L) { PROFILE
    dJointSetSliderAxis(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetSliderAxisDelta(dJointID, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az) [ from ode ]
static int l_OdeJointSetSliderAxisDelta (lua_State *L) { PROFILE
    dJointSetSliderAxisDelta(JOINTID(1), GETVEC(2), GETVEC(5));
    return 0;
}

// lua : void OdeJointSetSliderParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetSliderParam (lua_State *L) { PROFILE
    dJointSetSliderParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointAddSliderForce(dJointID joint, dReal force) [ from ode ]
static int l_OdeJointAddSliderForce (lua_State *L) { PROFILE
    dJointAddSliderForce(JOINTID(1), GETNUMBER(2));
    return 0;
}

// lua : void OdeJointSetHinge2Anchor(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetHinge2Anchor (lua_State *L) { PROFILE
    dJointSetHinge2Anchor(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetHinge2Axis1(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetHinge2Axis1 (lua_State *L) { PROFILE
    dJointSetHinge2Axis1(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetHinge2Axis2(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetHinge2Axis2 (lua_State *L) { PROFILE
    dJointSetHinge2Axis2(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetHinge2Param(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetHinge2Param (lua_State *L) { PROFILE
    dJointSetHinge2Param(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointAddHinge2Torques(dJointID joint, dReal torque1, dReal torque2) [ from ode ]
static int l_OdeJointAddHinge2Torques (lua_State *L) { PROFILE
    dJointAddHinge2Torques(JOINTID(1), GETNUMBER(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetUniversalAnchor(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetUniversalAnchor (lua_State *L) { PROFILE
    dJointSetUniversalAnchor(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetUniversalAxis1(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetUniversalAxis1 (lua_State *L) { PROFILE
    dJointSetUniversalAxis1(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetUniversalAxis2(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetUniversalAxis2 (lua_State *L) { PROFILE
    dJointSetUniversalAxis2(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetUniversalParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetUniversalParam (lua_State *L) { PROFILE
    dJointSetUniversalParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointAddUniversalTorques(dJointID joint, dReal torque1, dReal torque2) [ from ode ]
static int l_OdeJointAddUniversalTorques (lua_State *L) { PROFILE
    dJointAddUniversalTorques(JOINTID(1), GETNUMBER(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetPRAnchor(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetPRAnchor (lua_State *L) { PROFILE
    dJointSetPRAnchor(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetPRAxis1(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetPRAxis1 (lua_State *L) { PROFILE
    dJointSetPRAxis1(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetPRAxis2(dJointID, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetPRAxis2 (lua_State *L) { PROFILE
    dJointSetPRAxis2(JOINTID(1), GETVEC(2));
    return 0;
}

// lua : void OdeJointSetPRParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetPRParam (lua_State *L) { PROFILE
    dJointSetPRParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointAddPRTorque(dJointID j, dReal torque) [ from ode ]
static int l_OdeJointAddPRTorque (lua_State *L) { PROFILE
    dJointAddPRTorque(JOINTID(1), GETNUMBER(2));
    return 0;
}

// lua : void OdeJointSetFixed(dJointID) [ from ode ]
static int l_OdeJointSetFixed (lua_State *L) { PROFILE
    dJointSetFixed(JOINTID(1));
    return 0;
}

// lua : void OdeJointSetAMotorNumAxes(dJointID, int num) [ from ode ]
static int l_OdeJointSetAMotorNumAxes (lua_State *L) { PROFILE
    dJointSetAMotorNumAxes(JOINTID(1), GETINT(2));
    return 0;
}

// lua : void OdeJointSetAMotorAxis(dJointID, int anum, int rel,dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetAMotorAxis (lua_State *L) { PROFILE
    dJointSetAMotorAxis(JOINTID(1), GETINT(2), GETINT(3), GETVEC(4));
    return 0;
}

// lua : void OdeJointSetAMotorAngle(dJointID, int anum, dReal angle) [ from ode ]
static int l_OdeJointSetAMotorAngle (lua_State *L) { PROFILE
    dJointSetAMotorAngle(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetAMotorParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetAMotorParam (lua_State *L) { PROFILE
    dJointSetAMotorParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetAMotorMode(dJointID, int mode) [ from ode ]
static int l_OdeJointSetAMotorMode (lua_State *L) { PROFILE
    dJointSetAMotorMode(JOINTID(1), GETINT(2));
    return 0;
}

// lua : void OdeJointAddAMotorTorques(dJointID, dReal torque1, dReal torque2, dReal torque3) [ from ode ]
static int l_OdeJointAddAMotorTorques (lua_State *L) { PROFILE
    dJointAddAMotorTorques(JOINTID(1), GETNUMBER(2), GETNUMBER(3), GETNUMBER(4));
    return 0;
}

// lua : void OdeJointSetLMotorNumAxes(dJointID, int num) [ from ode ]
static int l_OdeJointSetLMotorNumAxes (lua_State *L) { PROFILE
    dJointSetLMotorNumAxes(JOINTID(1), GETINT(2));
    return 0;
}

// lua : void OdeJointSetLMotorAxis(dJointID, int anum, int rel, dReal x, dReal y, dReal z) [ from ode ]
static int l_OdeJointSetLMotorAxis (lua_State *L) { PROFILE
    dJointSetLMotorAxis(JOINTID(1), GETINT(2), GETINT(3), GETVEC(4));
    return 0;
}

// lua : void OdeJointSetLMotorParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetLMotorParam (lua_State *L) { PROFILE
    dJointSetLMotorParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetPlane2DXParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetPlane2DXParam (lua_State *L) { PROFILE
    dJointSetPlane2DXParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetPlane2DYParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetPlane2DYParam (lua_State *L) { PROFILE
    dJointSetPlane2DYParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointSetPlane2DAngleParam(dJointID, int parameter, dReal value) [ from ode ]
static int l_OdeJointSetPlane2DAngleParam (lua_State *L) { PROFILE
    dJointSetPlane2DAngleParam(JOINTID(1), GETINT(2), GETNUMBER(3));
    return 0;
}

// lua : void OdeJointGetBallAnchor(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetBallAnchor (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetBallAnchor(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetBallAnchor2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetBallAnchor2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetBallAnchor2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetHingeAnchor(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHingeAnchor (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHingeAnchor(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetHingeAnchor2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHingeAnchor2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHingeAnchor2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetHingeAxis(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHingeAxis (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHingeAxis(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetHingeParam(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetHingeParam (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHingeParam(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : dReal OdeJointGetHingeAngle(dJointID) [ from ode ]
static int l_OdeJointGetHingeAngle (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHingeAngle(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetHingeAngleRate(dJointID) [ from ode ]
static int l_OdeJointGetHingeAngleRate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHingeAngleRate(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetSliderPosition(dJointID) [ from ode ]
static int l_OdeJointGetSliderPosition (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetSliderPosition(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetSliderPositionRate(dJointID) [ from ode ]
static int l_OdeJointGetSliderPositionRate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetSliderPositionRate(JOINTID(1)) );
    return 1;
}

// lua : void OdeJointGetSliderAxis(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetSliderAxis (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetSliderAxis(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetSliderParam(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetSliderParam (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetSliderParam(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : void OdeJointGetHinge2Anchor(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHinge2Anchor (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHinge2Anchor(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetHinge2Anchor2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHinge2Anchor2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHinge2Anchor2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetHinge2Axis1(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHinge2Axis1 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHinge2Axis1(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetHinge2Axis2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetHinge2Axis2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetHinge2Axis2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetHinge2Param(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetHinge2Param (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHinge2Param(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : dReal OdeJointGetHinge2Angle1(dJointID) [ from ode ]
static int l_OdeJointGetHinge2Angle1 (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHinge2Angle1(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetHinge2Angle1Rate(dJointID) [ from ode ]
static int l_OdeJointGetHinge2Angle1Rate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHinge2Angle1Rate(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetHinge2Angle2Rate(dJointID) [ from ode ]
static int l_OdeJointGetHinge2Angle2Rate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetHinge2Angle2Rate(JOINTID(1)) );
    return 1;
}

// lua : void OdeJointGetUniversalAnchor(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetUniversalAnchor (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetUniversalAnchor(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetUniversalAnchor2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetUniversalAnchor2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetUniversalAnchor2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetUniversalAxis1(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetUniversalAxis1 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetUniversalAxis1(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetUniversalAxis2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetUniversalAxis2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetUniversalAxis2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetUniversalParam(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetUniversalParam (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetUniversalParam(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : angle1,angle2 OdeJointGetUniversalAngles(dJointID, dReal *angle1, dReal *angle2) [ from ode ]
static int l_OdeJointGetUniversalAngles (lua_State *L) { PROFILE
    dReal angle1, angle2;
    // TODO is this correct with the switched axis
    printf("WARNING!!!! dJointGetUniversalAngles probably gives strange results due to axis switch\n");
    dJointGetUniversalAngles(JOINTID(1), &angle1, &angle2);
    PUSHNUMBER(angle1);
    PUSHNUMBER(angle2);
    return 2;
}

// lua : dReal OdeJointGetUniversalAngle1(dJointID) [ from ode ]
static int l_OdeJointGetUniversalAngle1 (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetUniversalAngle1(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetUniversalAngle2(dJointID) [ from ode ]
static int l_OdeJointGetUniversalAngle2 (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetUniversalAngle2(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetUniversalAngle1Rate(dJointID) [ from ode ]
static int l_OdeJointGetUniversalAngle1Rate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetUniversalAngle1Rate(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetUniversalAngle2Rate(dJointID) [ from ode ]
static int l_OdeJointGetUniversalAngle2Rate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetUniversalAngle2Rate(JOINTID(1)) );
    return 1;
}

// lua : void OdeJointGetPRAnchor(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetPRAnchor (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetPRAnchor(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetPRPosition(dJointID) [ from ode ]
static int l_OdeJointGetPRPosition (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetPRPosition(JOINTID(1)) );
    return 1;
}

// lua : dReal OdeJointGetPRPositionRate(dJointID) [ from ode ]
static int l_OdeJointGetPRPositionRate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetPRPositionRate(JOINTID(1)) );
    return 1;
}

// lua : void OdeJointGetPRAxis1(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetPRAxis1 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetPRAxis1(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : void OdeJointGetPRAxis2(dJointID, dVector3 result) [ from ode ]
static int l_OdeJointGetPRAxis2 (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetPRAxis2(JOINTID(1), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetPRParam(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetPRParam (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetPRParam(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : int OdeJointGetAMotorNumAxes(dJointID) [ from ode ]
static int l_OdeJointGetAMotorNumAxes (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetAMotorNumAxes(JOINTID(1)) );
    return 1;
}

// lua : void OdeJointGetAMotorAxis(dJointID, int anum, dVector3 result) [ from ode ]
static int l_OdeJointGetAMotorAxis (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetAMotorAxis(JOINTID(1), GETINT(2), result);
    PUSHVEC(result);
    return 3;
}

// lua : int OdeJointGetAMotorAxisRel(dJointID, int anum) [ from ode ]
static int l_OdeJointGetAMotorAxisRel (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetAMotorAxisRel(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : dReal OdeJointGetAMotorAngle(dJointID, int anum) [ from ode ]
static int l_OdeJointGetAMotorAngle (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetAMotorAngle(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : dReal OdeJointGetAMotorAngleRate(dJointID, int anum) [ from ode ]
static int l_OdeJointGetAMotorAngleRate (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetAMotorAngleRate(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : dReal OdeJointGetAMotorParam(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetAMotorParam (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetAMotorParam(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : int OdeJointGetAMotorMode(dJointID) [ from ode ]
static int l_OdeJointGetAMotorMode (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetAMotorMode(JOINTID(1)) );
    return 1;
}

// lua : int OdeJointGetLMotorNumAxes(dJointID) [ from ode ]
static int l_OdeJointGetLMotorNumAxes (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetLMotorNumAxes(JOINTID(1)) );
    return 1;
}

// lua : void OdeJointGetLMotorAxis(dJointID, int anum, dVector3 result) [ from ode ]
static int l_OdeJointGetLMotorAxis (lua_State *L) { PROFILE
    dVector3 result;
    dJointGetLMotorAxis(JOINTID(1), GETINT(2), result);
    PUSHVEC(result);
    return 3;
}

// lua : dReal OdeJointGetLMotorParam(dJointID, int parameter) [ from ode ]
static int l_OdeJointGetLMotorParam (lua_State *L) { PROFILE
    PUSHNUMBER( dJointGetLMotorParam(JOINTID(1), GETINT(2)) );
    return 1;
}

// lua : dJointID OdeConnectingJoint(dBodyID, dBodyID) [ from ode ]
static int l_OdeConnectingJoint (lua_State *L) { PROFILE
    PUSHUDATA( dConnectingJoint(BODYID(1), BODYID(2)) );
    return 1;
}

// lua : int OdeConnectingJointList(dBodyID, dBodyID, dJointID*) [ from ode ]
static int l_OdeConnectingJointList (lua_State *L) { PROFILE
    // TODO dConnectingJointList(dBodyID, dBodyID, dJointID*);
    return 0;
}

// lua : int OdeAreConnected(dBodyID, dBodyID) [ from ode ]
static int l_OdeAreConnected (lua_State *L) { PROFILE
    PUSHNUMBER( dAreConnected(BODYID(1), BODYID(2)) );
    return 1;
}

// lua : int OdeAreConnectedExcluding(dBodyID body1, dBodyID body2, int joint_type) [ from ode ]
static int l_OdeAreConnectedExcluding (lua_State *L) { PROFILE
    PUSHNUMBER( dAreConnectedExcluding(BODYID(1), BODYID(2), GETINT(3)) );
    return 1;
}


// lua : dStopwatch * l_OdeStopwatchCreate() [ from ode ]
static int l_OdeStopwatchCreate (lua_State *L) { PROFILE
    dStopwatch *p = new dStopwatch;
    PUSHUDATA(p);
    return 1;
}

// lua : void l_OdeStopwatchDestroy(dStopwatch *) [ from ode ]
static int l_OdeStopwatchDestroy (lua_State *L) { PROFILE
    dStopwatch *p = STOPWATCHID(1);
    if(p)delete p;
    return 0;
}

// lua : void OdeStopwatchReset(dStopwatch *) [ from ode ]
static int l_OdeStopwatchReset (lua_State *L) { PROFILE
    dStopwatchReset(STOPWATCHID(1));
    return 0;
}


// lua : void OdeStopwatchStart(dStopwatch *) [ from ode ]
static int l_OdeStopwatchStart (lua_State *L) { PROFILE
    dStopwatchStart(STOPWATCHID(1));
    return 0;
}


// lua : void OdeStopwatchStop(dStopwatch *) [ from ode ]
static int l_OdeStopwatchStop (lua_State *L) { PROFILE
    dStopwatchStop(STOPWATCHID(1));
    return 0;
}


// lua : double OdeStopwatchTime(dStopwatch *) [ from ode ]
static int l_OdeStopwatchTime (lua_State *L) { PROFILE
    PUSHNUMBER( dStopwatchTime(STOPWATCHID(1)) );
    return 1;
}

/* returns total time in secs */


/* code timers */
// lua : void OdeTimerStart(const char *description) [ from ode ]
static int l_OdeTimerStart (lua_State *L) { PROFILE
    dTimerStart(GETSTRING(1));
    return 0;
}

/* pass a static string here */
// lua : void OdeTimerNow(const char *description) [ from ode ]
static int l_OdeTimerNow (lua_State *L) { PROFILE
    dTimerNow(GETSTRING(1));
    return 0;
}

// lua : void OdeTimerEnd(void) [ from ode ]
static int l_OdeTimerEnd (lua_State *L) { PROFILE
    dTimerEnd();
    return 0;
}


/* resolution */

/* returns the timer ticks per second implied by the timing hardware or API.
 * the actual timer resolution may not be this great.
 */
// lua : double OdeTimerTicksPerSecond(void) [ from ode ]
static int l_OdeTimerTicksPerSecond (lua_State *L) { PROFILE
    PUSHNUMBER( dTimerTicksPerSecond() );
    return 1;
}

/* returns an estimate of the actual timer resolution, in seconds. this may
 * be greater than 1/ticks_per_second.
 */
// lua : double OdeTimerResolution(void) [ from ode ]
static int l_OdeTimerResolution (lua_State *L) { PROFILE
    PUSHNUMBER( dTimerResolution() );
    return 1;
}

void    RegisterLua_Ode_GlobalFunctions (lua_State* L) {
      
    cScripting::SetGlobal(L,"OdeInfinity",dInfinity);
    
    cScripting::SetGlobal(L,"OdeParamLoStop",dParamLoStop);
    cScripting::SetGlobal(L,"OdeParamHiStop",dParamHiStop);
    cScripting::SetGlobal(L,"OdeParamVel",dParamVel);
    cScripting::SetGlobal(L,"OdeParamFMax",dParamFMax);
    cScripting::SetGlobal(L,"OdeParamFudgeFactor",dParamFudgeFactor);
    cScripting::SetGlobal(L,"OdeParamBounce",dParamBounce);
    cScripting::SetGlobal(L,"OdeParamCFM",dParamCFM);
    cScripting::SetGlobal(L,"OdeParamStopERP",dParamStopERP);
    cScripting::SetGlobal(L,"OdeParamSuspensionERP",dParamSuspensionERP);
    cScripting::SetGlobal(L,"OdeParamSuspensionCFM",dParamSuspensionCFM);
    
    cScripting::SetGlobal(L,"OdeParamLoStop2",dParamLoStop2);
    cScripting::SetGlobal(L,"OdeParamHiStop2",dParamHiStop2);
    cScripting::SetGlobal(L,"OdeParamVel2",dParamVel2);
    cScripting::SetGlobal(L,"OdeParamFMax2",dParamFMax2);
    cScripting::SetGlobal(L,"OdeParamFudgeFactor2",dParamFudgeFactor2);
    cScripting::SetGlobal(L,"OdeParamBounce2",dParamBounce2);
    cScripting::SetGlobal(L,"OdeParamCFM2",dParamCFM2);
    cScripting::SetGlobal(L,"OdeParamStopERP2",dParamStopERP2);
    cScripting::SetGlobal(L,"OdeParamSuspensionERP2",dParamSuspensionERP2);
    cScripting::SetGlobal(L,"OdeParamSuspensionCFM2",dParamSuspensionCFM2);
    
    cScripting::SetGlobal(L,"OdeParamLoStop3",dParamLoStop3);
    cScripting::SetGlobal(L,"OdeParamHiStop3",dParamHiStop3);
    cScripting::SetGlobal(L,"OdeParamVel3",dParamVel3);
    cScripting::SetGlobal(L,"OdeParamFMax3",dParamFMax3);
    cScripting::SetGlobal(L,"OdeParamFudgeFactor3",dParamFudgeFactor3);
    cScripting::SetGlobal(L,"OdeParamBounce3",dParamBounce3);
    cScripting::SetGlobal(L,"OdeParamCFM3",dParamCFM3);
    cScripting::SetGlobal(L,"OdeParamStopERP3",dParamStopERP3);
    cScripting::SetGlobal(L,"OdeParamSuspensionERP3",dParamSuspensionERP3);
    cScripting::SetGlobal(L,"OdeParamSuspensionCFM3",dParamSuspensionCFM3);
    
    // surface modes
    cScripting::SetGlobal(L,"OdeContactMu2",dContactMu2);
    cScripting::SetGlobal(L,"OdeContactFDir1",dContactFDir1);
    cScripting::SetGlobal(L,"OdeContactBounce",dContactBounce);
    cScripting::SetGlobal(L,"OdeContactSoftERP",dContactSoftERP);
    cScripting::SetGlobal(L,"OdeContactSoftCFM",dContactSoftCFM);
    cScripting::SetGlobal(L,"OdeContactMotion1",dContactMotion1);
    cScripting::SetGlobal(L,"OdeContactMotion2",dContactMotion2);
    cScripting::SetGlobal(L,"OdeContactSlip1",dContactSlip1);
    cScripting::SetGlobal(L,"OdeContactSlip2",dContactSlip2);
    
    cScripting::SetGlobal(L,"OdeContactApprox0",dContactApprox0);
    cScripting::SetGlobal(L,"OdeContactApprox1_1",dContactApprox1_1);
    cScripting::SetGlobal(L,"OdeContactApprox1_1",dContactApprox1_1);
    cScripting::SetGlobal(L,"OdeContactApprox1",dContactApprox1);

    // geometry classes
    cScripting::SetGlobal(L,"OdeSphereClass",dSphereClass);
    cScripting::SetGlobal(L,"OdeBoxClass",dBoxClass);
    cScripting::SetGlobal(L,"OdeCapsuleClass",dCapsuleClass);
    cScripting::SetGlobal(L,"OdeCylinderClass",dCylinderClass);
    cScripting::SetGlobal(L,"OdePlaneClass",dPlaneClass);
    cScripting::SetGlobal(L,"OdeRayClass",dRayClass);
    cScripting::SetGlobal(L,"OdeConvexClass",dConvexClass);
    cScripting::SetGlobal(L,"OdeGeomTransformClass",dGeomTransformClass);
    cScripting::SetGlobal(L,"OdeTriMeshClass",dTriMeshClass);
    cScripting::SetGlobal(L,"OdeHeightfieldClass",dHeightfieldClass);
    cScripting::SetGlobal(L,"OdeFirstSpaceClass",dFirstSpaceClass);
    cScripting::SetGlobal(L,"OdeSimpleSpaceClass",dSimpleSpaceClass);
    cScripting::SetGlobal(L,"OdeQuadTreeSpaceClass",dQuadTreeSpaceClass);
    cScripting::SetGlobal(L,"OdeLastSpaceClass",dLastSpaceClass);
    cScripting::SetGlobal(L,"OdeFirstUserClass",dFirstUserClass);
    cScripting::SetGlobal(L,"OdeLastUserClass",dLastUserClass);
    cScripting::SetGlobal(L,"OdeGeomNumClasses",dGeomNumClasses);


    // joint types  
    cScripting::SetGlobal(L,"OdeJointTypeNone",dJointTypeNone);
    cScripting::SetGlobal(L,"OdeJointTypeBall",dJointTypeBall);
    cScripting::SetGlobal(L,"OdeJointTypeHinge",dJointTypeHinge);
    cScripting::SetGlobal(L,"OdeJointTypeSlider",dJointTypeSlider);
    cScripting::SetGlobal(L,"OdeJointTypeContact",dJointTypeContact);
    cScripting::SetGlobal(L,"OdeJointTypeUniversal",dJointTypeUniversal);
    cScripting::SetGlobal(L,"OdeJointTypeHinge2",dJointTypeHinge2);
    cScripting::SetGlobal(L,"OdeJointTypeFixed",dJointTypeFixed);
    cScripting::SetGlobal(L,"OdeJointTypeNull",dJointTypeNull);
    cScripting::SetGlobal(L,"OdeJointTypeAMotor",dJointTypeAMotor);
    cScripting::SetGlobal(L,"OdeJointTypeLMotor",dJointTypeLMotor);
    cScripting::SetGlobal(L,"OdeJointTypePlane2D",dJointTypePlane2D);
    cScripting::SetGlobal(L,"OdeJointTypePR",dJointTypePR);
 

    lua_register(L,"OdeGeomSetData",l_OdeGeomSetData);
    lua_register(L,"OdeGeomGetData",l_OdeGeomGetData);
    lua_register(L,"OdeGeomSetBody",l_OdeGeomSetBody);
    lua_register(L,"OdeGeomGetBody",l_OdeGeomGetBody);
    lua_register(L,"OdeGeomSetPosition",l_OdeGeomSetPosition);
    lua_register(L,"OdeGeomSetQuaternion",l_OdeGeomSetQuaternion);
    lua_register(L,"OdeGeomGetPosition",l_OdeGeomGetPosition);
    lua_register(L,"OdeGeomGetQuaternion",l_OdeGeomGetQuaternion);
    lua_register(L,"OdeGeomGetAABB",l_OdeGeomGetAABB);
    lua_register(L,"OdeGeomIsSpace",l_OdeGeomIsSpace);
    lua_register(L,"OdeGeomGetSpace",l_OdeGeomGetSpace);
    lua_register(L,"OdeGeomGetClass",l_OdeGeomGetClass);
    lua_register(L,"OdeGeomSetCategoryBits",l_OdeGeomSetCategoryBits);
    lua_register(L,"OdeGeomSetCollideBits",l_OdeGeomSetCollideBits);
    lua_register(L,"OdeGeomGetCategoryBits",l_OdeGeomGetCategoryBits);
    lua_register(L,"OdeGeomGetCollideBits",l_OdeGeomGetCollideBits);
    lua_register(L,"OdeGeomEnable",l_OdeGeomEnable);
    lua_register(L,"OdeGeomDisable",l_OdeGeomDisable);
    lua_register(L,"OdeGeomIsEnabled",l_OdeGeomIsEnabled);
    lua_register(L,"OdeGeomSetOffsetPosition",l_OdeGeomSetOffsetPosition);
    lua_register(L,"OdeGeomSetOffsetQuaternion",l_OdeGeomSetOffsetQuaternion);
    lua_register(L,"OdeGeomSetOffsetWorldPosition",l_OdeGeomSetOffsetWorldPosition);
    lua_register(L,"OdeGeomSetOffsetWorldQuaternion",l_OdeGeomSetOffsetWorldQuaternion);
    lua_register(L,"OdeGeomClearOffset",l_OdeGeomClearOffset);
    lua_register(L,"OdeGeomIsOffset",l_OdeGeomIsOffset);
    lua_register(L,"OdeGeomGetOffsetPosition",l_OdeGeomGetOffsetPosition);
    lua_register(L,"OdeGeomGetOffsetQuaternion",l_OdeGeomGetOffsetQuaternion);
    lua_register(L,"OdeCollide",l_OdeCollide);
    lua_register(L,"OdeSpaceCollide",l_OdeSpaceCollide);
    lua_register(L,"OdeSpaceCollide2",l_OdeSpaceCollide2);
    lua_register(L,"OdeCreateSphere",l_OdeCreateSphere);
    lua_register(L,"OdeGeomSphereSetRadius",l_OdeGeomSphereSetRadius);
    lua_register(L,"OdeGeomSphereGetRadius",l_OdeGeomSphereGetRadius);
    lua_register(L,"OdeGeomSpherePointDepth",l_OdeGeomSpherePointDepth);
    lua_register(L,"OdeCreateConvex",l_OdeCreateConvex);
    lua_register(L,"OdeGeomSetConvex",l_OdeGeomSetConvex);
    lua_register(L,"OdeCreateBox",l_OdeCreateBox);
    lua_register(L,"OdeGeomBoxSetLengths",l_OdeGeomBoxSetLengths);
    lua_register(L,"OdeGeomBoxGetLengths",l_OdeGeomBoxGetLengths);
    lua_register(L,"OdeGeomBoxPointDepth",l_OdeGeomBoxPointDepth);
    lua_register(L,"OdeCreatePlane",l_OdeCreatePlane);
    lua_register(L,"OdeGeomPlaneSetParams",l_OdeGeomPlaneSetParams);
    lua_register(L,"OdeGeomPlaneGetParams",l_OdeGeomPlaneGetParams);
    lua_register(L,"OdeGeomPlanePointDepth",l_OdeGeomPlanePointDepth);
    lua_register(L,"OdeCreateCapsule",l_OdeCreateCapsule);
    lua_register(L,"OdeGeomCapsuleSetParams",l_OdeGeomCapsuleSetParams);
    lua_register(L,"OdeGeomCapsuleGetParams",l_OdeGeomCapsuleGetParams);
    lua_register(L,"OdeGeomCapsulePointDepth",l_OdeGeomCapsulePointDepth);
    lua_register(L,"OdeGeomCylinderSetParams",l_OdeGeomCylinderSetParams);
    lua_register(L,"OdeGeomCylinderGetParams",l_OdeGeomCylinderGetParams);
    lua_register(L,"OdeCreateRay",l_OdeCreateRay);
    lua_register(L,"OdeGeomRaySetLength",l_OdeGeomRaySetLength);
    lua_register(L,"OdeGeomRayGetLength",l_OdeGeomRayGetLength);
    lua_register(L,"OdeGeomRaySet",l_OdeGeomRaySet);
    lua_register(L,"OdeGeomRayGet",l_OdeGeomRayGet);
    lua_register(L,"OdeGeomRaySetParams",l_OdeGeomRaySetParams);
    lua_register(L,"OdeGeomRayGetParams",l_OdeGeomRayGetParams);
    lua_register(L,"OdeGeomRaySetClosestHit",l_OdeGeomRaySetClosestHit);
    lua_register(L,"OdeGeomRayGetClosestHit",l_OdeGeomRayGetClosestHit);
    lua_register(L,"OdeGeomTransformSetGeom",l_OdeGeomTransformSetGeom);
    lua_register(L,"OdeGeomTransformGetGeom",l_OdeGeomTransformGetGeom);
    lua_register(L,"OdeGeomTransformSetCleanup",l_OdeGeomTransformSetCleanup);
    lua_register(L,"OdeGeomTransformGetCleanup",l_OdeGeomTransformGetCleanup);
    lua_register(L,"OdeGeomTransformSetInfo",l_OdeGeomTransformSetInfo);
    lua_register(L,"OdeGeomTransformGetInfo",l_OdeGeomTransformGetInfo);
    lua_register(L,"OdeCreateHeightfield",l_OdeCreateHeightfield);
    lua_register(L,"OdeGeomHeightfieldDataDestroy",l_OdeGeomHeightfieldDataDestroy);
    lua_register(L,"OdeGeomHeightfieldDataBuildCallback",l_OdeGeomHeightfieldDataBuildCallback);
    lua_register(L,"OdeGeomHeightfieldDataBuildByte",l_OdeGeomHeightfieldDataBuildByte);
    lua_register(L,"OdeGeomHeightfieldDataBuildShort",l_OdeGeomHeightfieldDataBuildShort);
    lua_register(L,"OdeGeomHeightfieldDataBuildSingle",l_OdeGeomHeightfieldDataBuildSingle);
    lua_register(L,"OdeGeomHeightfieldDataBuildDouble",l_OdeGeomHeightfieldDataBuildDouble);
    lua_register(L,"OdeGeomHeightfieldDataSetBounds",l_OdeGeomHeightfieldDataSetBounds);
    lua_register(L,"OdeGeomHeightfieldSetHeightfieldData",l_OdeGeomHeightfieldSetHeightfieldData);
    lua_register(L,"OdeGeomHeightfieldGetHeightfieldData",l_OdeGeomHeightfieldGetHeightfieldData);
    lua_register(L,"OdeClosestLineSegmentPoints",l_OdeClosestLineSegmentPoints);
    lua_register(L,"OdeBoxTouchesBox",l_OdeBoxTouchesBox);
    lua_register(L,"OdeInfiniteAABB",l_OdeInfiniteAABB);
    lua_register(L,"OdeInitODE",l_OdeInitODE);
    lua_register(L,"OdeCloseODE",l_OdeCloseODE);
    lua_register(L,"OdeCreateGeomClass",l_OdeCreateGeomClass);
    lua_register(L,"OdeGeomGetClassData",l_OdeGeomGetClassData);
    lua_register(L,"OdeCreateGeom",l_OdeCreateGeom);
    lua_register(L,"OdeSimpleSpaceCreate",l_OdeSimpleSpaceCreate);
    lua_register(L,"OdeHashSpaceCreate",l_OdeHashSpaceCreate);
    lua_register(L,"OdeQuadTreeSpaceCreate",l_OdeQuadTreeSpaceCreate);
    lua_register(L,"OdeSpaceDestroy",l_OdeSpaceDestroy);
    lua_register(L,"OdeHashSpaceSetLevels",l_OdeHashSpaceSetLevels);
    lua_register(L,"OdeHashSpaceGetLevels",l_OdeHashSpaceGetLevels);
    lua_register(L,"OdeSpaceSetCleanup",l_OdeSpaceSetCleanup);
    lua_register(L,"OdeSpaceGetCleanup",l_OdeSpaceGetCleanup);
    lua_register(L,"OdeSpaceAdd",l_OdeSpaceAdd);
    lua_register(L,"OdeSpaceRemove",l_OdeSpaceRemove);
    lua_register(L,"OdeSpaceQuery",l_OdeSpaceQuery);
    lua_register(L,"OdeSpaceClean",l_OdeSpaceClean);
    lua_register(L,"OdeSpaceGetNumGeoms",l_OdeSpaceGetNumGeoms);
    lua_register(L,"OdeSpaceGetGeom",l_OdeSpaceGetGeom);
    lua_register(L,"OdeGeomTriMeshDataCreate",l_OdeGeomTriMeshDataCreate);
    lua_register(L,"OdeGeomTriMeshDataDestroy",l_OdeGeomTriMeshDataDestroy);
    lua_register(L,"OdeGeomTriMeshDataSet",l_OdeGeomTriMeshDataSet);
    lua_register(L,"OdeGeomTriMeshDataGet",l_OdeGeomTriMeshDataGet);
    lua_register(L,"OdeGeomTriMeshSetLastTransform",l_OdeGeomTriMeshSetLastTransform);
    lua_register(L,"OdeGeomTriMeshGetLastTransform",l_OdeGeomTriMeshGetLastTransform);
    lua_register(L,"OdeGeomTriMeshDataBuildSingle",l_OdeGeomTriMeshDataBuildSingle);
    lua_register(L,"OdeGeomTriMeshDataBuildSingle1",l_OdeGeomTriMeshDataBuildSingle1);
    lua_register(L,"OdeGeomTriMeshDataBuildDouble",l_OdeGeomTriMeshDataBuildDouble);
    lua_register(L,"OdeGeomTriMeshDataBuildDouble1",l_OdeGeomTriMeshDataBuildDouble1);
    lua_register(L,"OdeGeomTriMeshDataBuildFromRaw",l_OdeGeomTriMeshDataBuildFromRaw);
    lua_register(L,"OdeGeomTriMeshDataBuildSimple1",l_OdeGeomTriMeshDataBuildSimple1);
    lua_register(L,"OdeGeomTriMeshDataPreprocess",l_OdeGeomTriMeshDataPreprocess);
    lua_register(L,"OdeGeomTriMeshDataGetBuffer",l_OdeGeomTriMeshDataGetBuffer);
    lua_register(L,"OdeGeomTriMeshDataSetBuffer",l_OdeGeomTriMeshDataSetBuffer);
    lua_register(L,"OdeGeomTriMeshSetCallback",l_OdeGeomTriMeshSetCallback);
    lua_register(L,"OdeGeomTriMeshGetCallback",l_OdeGeomTriMeshGetCallback);
    lua_register(L,"OdeGeomTriMeshSetArrayCallback",l_OdeGeomTriMeshSetArrayCallback);
    lua_register(L,"OdeGeomTriMeshGetArrayCallback",l_OdeGeomTriMeshGetArrayCallback);
    lua_register(L,"OdeGeomTriMeshSetRayCallback",l_OdeGeomTriMeshSetRayCallback);
    lua_register(L,"OdeGeomTriMeshGetRayCallback",l_OdeGeomTriMeshGetRayCallback);
    lua_register(L,"OdeCreateTriMesh",l_OdeCreateTriMesh);
    lua_register(L,"OdeGeomTriMeshSetData",l_OdeGeomTriMeshSetData);
    lua_register(L,"OdeGeomTriMeshGetData",l_OdeGeomTriMeshGetData);
    lua_register(L,"OdeGeomTriMeshEnableTC",l_OdeGeomTriMeshEnableTC);
    lua_register(L,"OdeGeomTriMeshIsTCEnabled",l_OdeGeomTriMeshIsTCEnabled);
    lua_register(L,"OdeGeomTriMeshClearTCCache",l_OdeGeomTriMeshClearTCCache);
    lua_register(L,"OdeGeomTriMeshGetTriMeshDataID",l_OdeGeomTriMeshGetTriMeshDataID);
    lua_register(L,"OdeGeomTriMeshGetTriangle",l_OdeGeomTriMeshGetTriangle);
    lua_register(L,"OdeGeomTriMeshGetPoint",l_OdeGeomTriMeshGetPoint);
    lua_register(L,"OdeGeomTriMeshGetTriangleCount",l_OdeGeomTriMeshGetTriangleCount);
    lua_register(L,"OdeGeomTriMeshDataUpdate",l_OdeGeomTriMeshDataUpdate);
    lua_register(L,"OdeMassCreate",l_OdeMassCreate);
    lua_register(L,"OdeMassDestroy",l_OdeMassDestroy);
    lua_register(L,"OdeMassCheck",l_OdeMassCheck);
    lua_register(L,"OdeMassSetZero",l_OdeMassSetZero);
    lua_register(L,"OdeMassSetParameters",l_OdeMassSetParameters);
    lua_register(L,"OdeMassSetSphere",l_OdeMassSetSphere);
    lua_register(L,"OdeMassSetSphereTotal",l_OdeMassSetSphereTotal);
    lua_register(L,"OdeMassSetCapsule",l_OdeMassSetCapsule);
    lua_register(L,"OdeMassSetCapsuleTotal",l_OdeMassSetCapsuleTotal);
    lua_register(L,"OdeMassSetCylinder",l_OdeMassSetCylinder);
    lua_register(L,"OdeMassSetCylinderTotal",l_OdeMassSetCylinderTotal);
    lua_register(L,"OdeMassSetBox",l_OdeMassSetBox);
    lua_register(L,"OdeMassSetBoxTotal",l_OdeMassSetBoxTotal);
    lua_register(L,"OdeMassSetTrimesh",l_OdeMassSetTrimesh);
    lua_register(L,"OdeMassAdjust",l_OdeMassAdjust);
    lua_register(L,"OdeMassTranslate",l_OdeMassTranslate);
    lua_register(L,"OdeMassAdd",l_OdeMassAdd);
    lua_register(L,"OdeWorldDestroy",l_OdeWorldDestroy);
    lua_register(L,"OdeWorldCreate",l_OdeWorldCreate);
    lua_register(L,"OdeWorldSetGravity",l_OdeWorldSetGravity);
    lua_register(L,"OdeWorldGetGravity",l_OdeWorldGetGravity);
    lua_register(L,"OdeWorldSetERP",l_OdeWorldSetERP);
    lua_register(L,"OdeWorldGetERP",l_OdeWorldGetERP);
    lua_register(L,"OdeWorldSetCFM",l_OdeWorldSetCFM);
    lua_register(L,"OdeWorldGetCFM",l_OdeWorldGetCFM);
    lua_register(L,"OdeWorldStep",l_OdeWorldStep);
    lua_register(L,"OdeWorldImpulseToForce",l_OdeWorldImpulseToForce);
    lua_register(L,"OdeWorldQuickStep",l_OdeWorldQuickStep);
    lua_register(L,"OdeWorldSetQuickStepNumIterations",l_OdeWorldSetQuickStepNumIterations);
    lua_register(L,"OdeWorldGetQuickStepNumIterations",l_OdeWorldGetQuickStepNumIterations);
    lua_register(L,"OdeWorldSetQuickStepW",l_OdeWorldSetQuickStepW);
    lua_register(L,"OdeWorldGetQuickStepW",l_OdeWorldGetQuickStepW);
    lua_register(L,"OdeWorldSetContactMaxCorrectingVel",l_OdeWorldSetContactMaxCorrectingVel);
    lua_register(L,"OdeWorldGetContactMaxCorrectingVel",l_OdeWorldGetContactMaxCorrectingVel);
    lua_register(L,"OdeWorldSetContactSurfaceLayer",l_OdeWorldSetContactSurfaceLayer);
    lua_register(L,"OdeWorldGetContactSurfaceLayer",l_OdeWorldGetContactSurfaceLayer);
    lua_register(L,"OdeWorldStepFast1",l_OdeWorldStepFast1);
    lua_register(L,"OdeWorldSetAutoEnableDepthSF1",l_OdeWorldSetAutoEnableDepthSF1);
    lua_register(L,"OdeWorldGetAutoEnableDepthSF1",l_OdeWorldGetAutoEnableDepthSF1);
    lua_register(L,"OdeWorldGetAutoDisableLinearThreshold",l_OdeWorldGetAutoDisableLinearThreshold);
    lua_register(L,"OdeWorldSetAutoDisableLinearThreshold",l_OdeWorldSetAutoDisableLinearThreshold);
    lua_register(L,"OdeWorldGetAutoDisableAngularThreshold",l_OdeWorldGetAutoDisableAngularThreshold);
    lua_register(L,"OdeWorldSetAutoDisableAngularThreshold",l_OdeWorldSetAutoDisableAngularThreshold);
    lua_register(L,"OdeWorldGetAutoDisableLinearAverageThreshold",l_OdeWorldGetAutoDisableLinearAverageThreshold);
    lua_register(L,"OdeWorldSetAutoDisableLinearAverageThreshold",l_OdeWorldSetAutoDisableLinearAverageThreshold);
    lua_register(L,"OdeWorldGetAutoDisableAngularAverageThreshold",l_OdeWorldGetAutoDisableAngularAverageThreshold);
    lua_register(L,"OdeWorldSetAutoDisableAngularAverageThreshold",l_OdeWorldSetAutoDisableAngularAverageThreshold);
    lua_register(L,"OdeWorldGetAutoDisableAverageSamplesCount",l_OdeWorldGetAutoDisableAverageSamplesCount);
    lua_register(L,"OdeWorldSetAutoDisableAverageSamplesCount",l_OdeWorldSetAutoDisableAverageSamplesCount);
    lua_register(L,"OdeWorldGetAutoDisableSteps",l_OdeWorldGetAutoDisableSteps);
    lua_register(L,"OdeWorldSetAutoDisableSteps",l_OdeWorldSetAutoDisableSteps);
    lua_register(L,"OdeWorldGetAutoDisableTime",l_OdeWorldGetAutoDisableTime);
    lua_register(L,"OdeWorldSetAutoDisableTime",l_OdeWorldSetAutoDisableTime);
    lua_register(L,"OdeWorldGetAutoDisableFlag",l_OdeWorldGetAutoDisableFlag);
    lua_register(L,"OdeWorldSetAutoDisableFlag",l_OdeWorldSetAutoDisableFlag);
    lua_register(L,"OdeBodyGetAutoDisableLinearThreshold",l_OdeBodyGetAutoDisableLinearThreshold);
    lua_register(L,"OdeBodySetAutoDisableLinearThreshold",l_OdeBodySetAutoDisableLinearThreshold);
    lua_register(L,"OdeBodyGetAutoDisableAngularThreshold",l_OdeBodyGetAutoDisableAngularThreshold);
    lua_register(L,"OdeBodySetAutoDisableAngularThreshold",l_OdeBodySetAutoDisableAngularThreshold);
    lua_register(L,"OdeBodyGetAutoDisableAverageSamplesCount",l_OdeBodyGetAutoDisableAverageSamplesCount);
    lua_register(L,"OdeBodySetAutoDisableAverageSamplesCount",l_OdeBodySetAutoDisableAverageSamplesCount);
    lua_register(L,"OdeBodyGetAutoDisableSteps",l_OdeBodyGetAutoDisableSteps);
    lua_register(L,"OdeBodySetAutoDisableSteps",l_OdeBodySetAutoDisableSteps);
    lua_register(L,"OdeBodyGetAutoDisableTime",l_OdeBodyGetAutoDisableTime);
    lua_register(L,"OdeBodySetAutoDisableTime",l_OdeBodySetAutoDisableTime);
    lua_register(L,"OdeBodyGetAutoDisableFlag",l_OdeBodyGetAutoDisableFlag);
    lua_register(L,"OdeBodySetAutoDisableFlag",l_OdeBodySetAutoDisableFlag);
    lua_register(L,"OdeBodySetAutoDisableDefaults",l_OdeBodySetAutoDisableDefaults);
    lua_register(L,"OdeBodyGetWorld",l_OdeBodyGetWorld);
    lua_register(L,"OdeBodyCreate",l_OdeBodyCreate);
    lua_register(L,"OdeBodyDestroy",l_OdeBodyDestroy);
    lua_register(L,"OdeBodySetData",l_OdeBodySetData);
    lua_register(L,"OdeBodyGetData",l_OdeBodyGetData);
    lua_register(L,"OdeBodySetPosition",l_OdeBodySetPosition);
    lua_register(L,"OdeBodySetQuaternion",l_OdeBodySetQuaternion);
    lua_register(L,"OdeBodySetLinearVel",l_OdeBodySetLinearVel);
    lua_register(L,"OdeBodySetAngularVel",l_OdeBodySetAngularVel);
    lua_register(L,"OdeBodyGetPosition",l_OdeBodyGetPosition);
    lua_register(L,"OdeBodyGetQuaternion",l_OdeBodyGetQuaternion);
    lua_register(L,"OdeBodyGetLinearVel",l_OdeBodyGetLinearVel);
    lua_register(L,"OdeBodyGetAngularVel",l_OdeBodyGetAngularVel);
    lua_register(L,"OdeBodySetMass",l_OdeBodySetMass);
    lua_register(L,"OdeBodyGetMass",l_OdeBodyGetMass);
    lua_register(L,"OdeBodyAddForce",l_OdeBodyAddForce);
    lua_register(L,"OdeBodyAddTorque",l_OdeBodyAddTorque);
    lua_register(L,"OdeBodyAddRelForce",l_OdeBodyAddRelForce);
    lua_register(L,"OdeBodyAddRelTorque",l_OdeBodyAddRelTorque);
    lua_register(L,"OdeBodyAddForceAtPos",l_OdeBodyAddForceAtPos);
    lua_register(L,"OdeBodyAddForceAtRelPos",l_OdeBodyAddForceAtRelPos);
    lua_register(L,"OdeBodyAddRelForceAtPos",l_OdeBodyAddRelForceAtPos);
    lua_register(L,"OdeBodyAddRelForceAtRelPos",l_OdeBodyAddRelForceAtRelPos);
    lua_register(L,"OdeBodyGetForce",l_OdeBodyGetForce);
    lua_register(L,"OdeBodyGetTorque",l_OdeBodyGetTorque);
    lua_register(L,"OdeBodySetForce",l_OdeBodySetForce);
    lua_register(L,"OdeBodySetTorque",l_OdeBodySetTorque);
    lua_register(L,"OdeBodyGetRelPointPos",l_OdeBodyGetRelPointPos);
    lua_register(L,"OdeBodyGetRelPointVel",l_OdeBodyGetRelPointVel);
    lua_register(L,"OdeBodyGetPointVel",l_OdeBodyGetPointVel);
    lua_register(L,"OdeBodyGetPosRelPoint",l_OdeBodyGetPosRelPoint);
    lua_register(L,"OdeBodyVectorToWorld",l_OdeBodyVectorToWorld);
    lua_register(L,"OdeBodyVectorFromWorld",l_OdeBodyVectorFromWorld);
    lua_register(L,"OdeBodySetFiniteRotationMode",l_OdeBodySetFiniteRotationMode);
    lua_register(L,"OdeBodySetFiniteRotationAxis",l_OdeBodySetFiniteRotationAxis);
    lua_register(L,"OdeBodyGetFiniteRotationMode",l_OdeBodyGetFiniteRotationMode);
    lua_register(L,"OdeBodyGetFiniteRotationAxis",l_OdeBodyGetFiniteRotationAxis);
    lua_register(L,"OdeBodyGetNumJoints",l_OdeBodyGetNumJoints);
    lua_register(L,"OdeBodyGetJoint",l_OdeBodyGetJoint);
    lua_register(L,"OdeBodyEnable",l_OdeBodyEnable);
    lua_register(L,"OdeBodyDisable",l_OdeBodyDisable);
    lua_register(L,"OdeBodyIsEnabled",l_OdeBodyIsEnabled);
    lua_register(L,"OdeBodySetGravityMode",l_OdeBodySetGravityMode);
    lua_register(L,"OdeBodyGetGravityMode",l_OdeBodyGetGravityMode);
    lua_register(L,"OdeJointCreateBall",l_OdeJointCreateBall);
    lua_register(L,"OdeJointCreateHinge",l_OdeJointCreateHinge);
    lua_register(L,"OdeJointCreateSlider",l_OdeJointCreateSlider);
    lua_register(L,"OdeJointCreateContact",l_OdeJointCreateContact);
    lua_register(L,"OdeJointCreateHinge2",l_OdeJointCreateHinge2);
    lua_register(L,"OdeJointCreateUniversal",l_OdeJointCreateUniversal);
    lua_register(L,"OdeJointCreatePR",l_OdeJointCreatePR);
    lua_register(L,"OdeJointCreateFixed",l_OdeJointCreateFixed);
    lua_register(L,"OdeJointCreateNull",l_OdeJointCreateNull);
    lua_register(L,"OdeJointCreateAMotor",l_OdeJointCreateAMotor);
    lua_register(L,"OdeJointCreateLMotor",l_OdeJointCreateLMotor);
    lua_register(L,"OdeJointCreatePlane2D",l_OdeJointCreatePlane2D);
    lua_register(L,"OdeJointDestroy",l_OdeJointDestroy);
    lua_register(L,"OdeJointGroupCreate",l_OdeJointGroupCreate);
    lua_register(L,"OdeJointGroupDestroy",l_OdeJointGroupDestroy);
    lua_register(L,"OdeJointGroupEmpty",l_OdeJointGroupEmpty);
    lua_register(L,"OdeJointAttach",l_OdeJointAttach);
    lua_register(L,"OdeJointSetData",l_OdeJointSetData);
    lua_register(L,"OdedJointGetData",l_OdedJointGetData);
    lua_register(L,"OdeJointGetType",l_OdeJointGetType);
    lua_register(L,"OdeJointGetBody",l_OdeJointGetBody);
    lua_register(L,"OdeJointSetFeedback",l_OdeJointSetFeedback);
    lua_register(L,"OdeJointFeedbackCreate",l_OdeJointFeedbackCreate);
    lua_register(L,"OdeJointFeedbackDestroy",l_OdeJointFeedbackDestroy);
    lua_register(L,"OdeJointGetFeedback",l_OdeJointGetFeedback);
    lua_register(L,"OdeJointSetBallAnchor",l_OdeJointSetBallAnchor);
    lua_register(L,"OdeJointSetBallAnchor2",l_OdeJointSetBallAnchor2);
    lua_register(L,"OdeJointSetHingeAnchor",l_OdeJointSetHingeAnchor);
    lua_register(L,"OdeJointSetHingeAnchorDelta",l_OdeJointSetHingeAnchorDelta);
    lua_register(L,"OdeJointSetHingeAxis",l_OdeJointSetHingeAxis);
    lua_register(L,"OdeJointSetHingeParam",l_OdeJointSetHingeParam);
    lua_register(L,"OdeJointAddHingeTorque",l_OdeJointAddHingeTorque);
    lua_register(L,"OdeJointSetSliderAxis",l_OdeJointSetSliderAxis);
    lua_register(L,"OdeJointSetSliderAxisDelta",l_OdeJointSetSliderAxisDelta);
    lua_register(L,"OdeJointSetSliderParam",l_OdeJointSetSliderParam);
    lua_register(L,"OdeJointAddSliderForce",l_OdeJointAddSliderForce);
    lua_register(L,"OdeJointSetHinge2Anchor",l_OdeJointSetHinge2Anchor);
    lua_register(L,"OdeJointSetHinge2Axis1",l_OdeJointSetHinge2Axis1);
    lua_register(L,"OdeJointSetHinge2Axis2",l_OdeJointSetHinge2Axis2);
    lua_register(L,"OdeJointSetHinge2Param",l_OdeJointSetHinge2Param);
    lua_register(L,"OdeJointAddHinge2Torques",l_OdeJointAddHinge2Torques);
    lua_register(L,"OdeJointSetUniversalAnchor",l_OdeJointSetUniversalAnchor);
    lua_register(L,"OdeJointSetUniversalAxis1",l_OdeJointSetUniversalAxis1);
    lua_register(L,"OdeJointSetUniversalAxis2",l_OdeJointSetUniversalAxis2);
    lua_register(L,"OdeJointSetUniversalParam",l_OdeJointSetUniversalParam);
    lua_register(L,"OdeJointAddUniversalTorques",l_OdeJointAddUniversalTorques);
    lua_register(L,"OdeJointSetPRAnchor",l_OdeJointSetPRAnchor);
    lua_register(L,"OdeJointSetPRAxis1",l_OdeJointSetPRAxis1);
    lua_register(L,"OdeJointSetPRAxis2",l_OdeJointSetPRAxis2);
    lua_register(L,"OdeJointSetPRParam",l_OdeJointSetPRParam);
    lua_register(L,"OdeJointAddPRTorque",l_OdeJointAddPRTorque);
    lua_register(L,"OdeJointSetFixed",l_OdeJointSetFixed);
    lua_register(L,"OdeJointSetAMotorNumAxes",l_OdeJointSetAMotorNumAxes);
    lua_register(L,"OdeJointSetAMotorAxis",l_OdeJointSetAMotorAxis);
    lua_register(L,"OdeJointSetAMotorAngle",l_OdeJointSetAMotorAngle);
    lua_register(L,"OdeJointSetAMotorParam",l_OdeJointSetAMotorParam);
    lua_register(L,"OdeJointSetAMotorMode",l_OdeJointSetAMotorMode);
    lua_register(L,"OdeJointAddAMotorTorques",l_OdeJointAddAMotorTorques);
    lua_register(L,"OdeJointSetLMotorNumAxes",l_OdeJointSetLMotorNumAxes);
    lua_register(L,"OdeJointSetLMotorAxis",l_OdeJointSetLMotorAxis);
    lua_register(L,"OdeJointSetLMotorParam",l_OdeJointSetLMotorParam);
    lua_register(L,"OdeJointSetPlane2DXParam",l_OdeJointSetPlane2DXParam);
    lua_register(L,"OdeJointSetPlane2DYParam",l_OdeJointSetPlane2DYParam);
    lua_register(L,"OdeJointSetPlane2DAngleParam",l_OdeJointSetPlane2DAngleParam);
    lua_register(L,"OdeJointGetBallAnchor",l_OdeJointGetBallAnchor);
    lua_register(L,"OdeJointGetBallAnchor2",l_OdeJointGetBallAnchor2);
    lua_register(L,"OdeJointGetHingeAnchor",l_OdeJointGetHingeAnchor);
    lua_register(L,"OdeJointGetHingeAnchor2",l_OdeJointGetHingeAnchor2);
    lua_register(L,"OdeJointGetHingeAxis",l_OdeJointGetHingeAxis);
    lua_register(L,"OdeJointGetHingeParam",l_OdeJointGetHingeParam);
    lua_register(L,"OdeJointGetHingeAngle",l_OdeJointGetHingeAngle);
    lua_register(L,"OdeJointGetHingeAngleRate",l_OdeJointGetHingeAngleRate);
    lua_register(L,"OdeJointGetSliderPosition",l_OdeJointGetSliderPosition);
    lua_register(L,"OdeJointGetSliderPositionRate",l_OdeJointGetSliderPositionRate);
    lua_register(L,"OdeJointGetSliderAxis",l_OdeJointGetSliderAxis);
    lua_register(L,"OdeJointGetSliderParam",l_OdeJointGetSliderParam);
    lua_register(L,"OdeJointGetHinge2Anchor",l_OdeJointGetHinge2Anchor);
    lua_register(L,"OdeJointGetHinge2Anchor2",l_OdeJointGetHinge2Anchor2);
    lua_register(L,"OdeJointGetHinge2Axis1",l_OdeJointGetHinge2Axis1);
    lua_register(L,"OdeJointGetHinge2Axis2",l_OdeJointGetHinge2Axis2);
    lua_register(L,"OdeJointGetHinge2Param",l_OdeJointGetHinge2Param);
    lua_register(L,"OdeJointGetHinge2Angle1",l_OdeJointGetHinge2Angle1);
    lua_register(L,"OdeJointGetHinge2Angle1Rate",l_OdeJointGetHinge2Angle1Rate);
    lua_register(L,"OdeJointGetHinge2Angle2Rate",l_OdeJointGetHinge2Angle2Rate);
    lua_register(L,"OdeJointGetUniversalAnchor",l_OdeJointGetUniversalAnchor);
    lua_register(L,"OdeJointGetUniversalAnchor2",l_OdeJointGetUniversalAnchor2);
    lua_register(L,"OdeJointGetUniversalAxis1",l_OdeJointGetUniversalAxis1);
    lua_register(L,"OdeJointGetUniversalAxis2",l_OdeJointGetUniversalAxis2);
    lua_register(L,"OdeJointGetUniversalParam",l_OdeJointGetUniversalParam);
    lua_register(L,"OdeJointGetUniversalAngles",l_OdeJointGetUniversalAngles);
    lua_register(L,"OdeJointGetUniversalAngle1",l_OdeJointGetUniversalAngle1);
    lua_register(L,"OdeJointGetUniversalAngle2",l_OdeJointGetUniversalAngle2);
    lua_register(L,"OdeJointGetUniversalAngle1Rate",l_OdeJointGetUniversalAngle1Rate);
    lua_register(L,"OdeJointGetUniversalAngle2Rate",l_OdeJointGetUniversalAngle2Rate);
    lua_register(L,"OdeJointGetPRAnchor",l_OdeJointGetPRAnchor);
    lua_register(L,"OdeJointGetPRPosition",l_OdeJointGetPRPosition);
    lua_register(L,"OdeJointGetPRPositionRate",l_OdeJointGetPRPositionRate);
    lua_register(L,"OdeJointGetPRAxis1",l_OdeJointGetPRAxis1);
    lua_register(L,"OdeJointGetPRAxis2",l_OdeJointGetPRAxis2);
    lua_register(L,"OdeJointGetPRParam",l_OdeJointGetPRParam);
    lua_register(L,"OdeJointGetAMotorNumAxes",l_OdeJointGetAMotorNumAxes);
    lua_register(L,"OdeJointGetAMotorAxis",l_OdeJointGetAMotorAxis);
    lua_register(L,"OdeJointGetAMotorAxisRel",l_OdeJointGetAMotorAxisRel);
    lua_register(L,"OdeJointGetAMotorAngle",l_OdeJointGetAMotorAngle);
    lua_register(L,"OdeJointGetAMotorAngleRate",l_OdeJointGetAMotorAngleRate);
    lua_register(L,"OdeJointGetAMotorParam",l_OdeJointGetAMotorParam);
    lua_register(L,"OdeJointGetAMotorMode",l_OdeJointGetAMotorMode);
    lua_register(L,"OdeJointGetLMotorNumAxes",l_OdeJointGetLMotorNumAxes);
    lua_register(L,"OdeJointGetLMotorAxis",l_OdeJointGetLMotorAxis);
    lua_register(L,"OdeJointGetLMotorParam",l_OdeJointGetLMotorParam);
    lua_register(L,"OdeConnectingJoint",l_OdeConnectingJoint);
    lua_register(L,"OdeConnectingJointList",l_OdeConnectingJointList);
    lua_register(L,"OdeAreConnected",l_OdeAreConnected);
    lua_register(L,"OdeAreConnectedExcluding",l_OdeAreConnectedExcluding);
    lua_register(L,"OdeStopwatchCreate",l_OdeStopwatchCreate);
    lua_register(L,"OdeStopwatchDestroy",l_OdeStopwatchDestroy);
    lua_register(L,"OdeStopwatchReset",l_OdeStopwatchReset);
    lua_register(L,"OdeStopwatchStart",l_OdeStopwatchStart);
    lua_register(L,"OdeStopwatchStop",l_OdeStopwatchStop);
    lua_register(L,"OdeStopwatchTime",l_OdeStopwatchTime);
    lua_register(L,"OdeTimerStart",l_OdeTimerStart);
    lua_register(L,"OdeTimerNow",l_OdeTimerNow);
    lua_register(L,"OdeTimerEnd",l_OdeTimerEnd);
    lua_register(L,"OdeTimerTicksPerSecond",l_OdeTimerTicksPerSecond);
    lua_register(L,"OdeTimerResolution",l_OdeTimerResolution);
    lua_register(L,"OdeContactGeomCreate",l_OdeContactGeomCreate);
    lua_register(L,"OdeContactGeomDestroy",l_OdeContactGeomDestroy);
    lua_register(L,"OdeGeomDestroy",l_OdeGeomDestroy);
    lua_register(L,"OdeContactGeomGetParams",l_OdeContactGeomGetParams);
    lua_register(L,"OdeTriMeshRawDataCreate",l_OdeTriMeshRawDataCreate);
    lua_register(L,"OdeTriMeshRawDataDestroy",l_OdeTriMeshRawDataDestroy);
    lua_register(L,"OdeTriMeshRawDataPrint",l_OdeTriMeshRawDataPrint);
    lua_register(L,"OdeGeomHeightfieldDataBuildFromFun",l_OdeGeomHeightfieldDataBuildFromFun);
    lua_register(L,"OdeGeomHeightfieldDataCreate",l_OdeGeomHeightfieldDataCreate);
    lua_register(L,"OdeGetContactSurface",l_OdeGetContactSurface);
    lua_register(L,"OdeSetContactSurface",l_OdeSetContactSurface);
    lua_register(L,"OdeGetContactGeom",l_OdeGetContactGeom);
    lua_register(L,"OdeSetContactGeom",l_OdeSetContactGeom);
}

#endif