SCOLPhysics.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
 
#include "SCOLPack/SO3SCOL.h"
 
// Physic includes
#include "SO3PhysicGraph/SO3Body.h"
 
#include "SO3PhysicGraph/SO3ShapeBox.h"
#include "SO3PhysicGraph/SO3ShapeCone.h"
#include "SO3PhysicGraph/SO3ShapeEllipsoid.h"
#include "SO3PhysicGraph/SO3ShapeCapsule.h"
#include "SO3PhysicGraph/SO3ShapeCylinder.h"
#include "SO3PhysicGraph/SO3ShapeChamferCylinder.h"
#include "SO3PhysicGraph/SO3ShapePyramid.h"
#include "SO3PhysicGraph/SO3ShapeConvexHull.h"
#include "SO3PhysicGraph/SO3ShapeConcaveHull.h"
#include "SO3PhysicGraph/SO3ShapeTree.h"
 
#include "SO3PhysicGraph/SO3PhysicContraint.h"
#include "SO3PhysicGraph/SO3BallAndSocketContraint.h"
#include "SO3PhysicGraph/SO3HingeContraint.h"
#include "SO3PhysicGraph/SO3SliderContraint.h"
#include "SO3PhysicGraph/SO3VehicleContraint.h"
 
#include "SO3PhysicGraph/SO3MaterialID.h"
#include "SO3PhysicGraph/SO3MaterialPair.h"
 
// Renderer includes
#include "SO3Renderer/SO3Root.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Scene.h"
 
int SO3_MATERIALPAIR_OVERLAP_STARTED_MSG;
int SO3_MATERIALPAIR_OVERLAP_ENDED_MSG;
int SO3_MATERIALPAIR_COLLISION_MSG;
//int SO3_BODY_LEAVE_WORLD_MSG;
 
/*int getBodyLeaveWorldCallback(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE objm)
{
#ifdef SO3_DEBUG
MMechostr(MSKDEBUG, "getBodyLeaveWorldCallback\n");
#endif
 
int k , res;
res = 0;
if(!(k = OBJbeginreflex(m, SO3PHYSICBODY, id, SO3_BODY_LEAVE_WORLD)))
res = OBJcallreflex(m, 0);
 
return res;
}*/
 
int getMaterialContactCallback(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getMaterialContactCallback\n");
#endif
 
  int obj, res;
  res = 0;
  MCOLL* result = (MCOLL*)param;
  SNode* node0 = result->curScene->GetNode(result->node0);
  SNode* node1 = result->curScene->GetNode(result->node1);
 
  if ((node0 == 0) || (node1 == 0))
    return 0;
 
  if (node0->GetSceneNodeBody() == NULL || node1->GetSceneNodeBody() == NULL)
    return 0;
 
  // equal to OBJbeginreflex
  // is there a callback assigned to the object?
  obj = OBJfindTH(m, SO3PHYSICSMATERIALPAIR, id);
  if (obj == NIL)
    return -1;
 
  if (MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_COLLISION * 2) == NIL)
    return -1;
 
  // retrieve scene magma
  int s = MMfetch(m, OBJfindTH(m, SO3SCENETYPE, SCOL_PTR(result->curScene)), OFFOBJMAG);
 
  int pos = MMmalloc(m, 3, TYPETAB);
  if (pos == NIL)
    return MERRMEM;
 
  int norm = MMmalloc(m, 3, TYPETAB);
  if (norm == NIL)
    return MERRMEM;
 
  int force = MMmalloc(m, 3, TYPETAB);
  if (force == NIL)
    return MERRMEM;
 
  //equal to OBJpreparereflex but replace the object
  MMsetglobal(m, OFFSCCUR, MMfetch(m, obj, OFFOBJCHN));
  if (MMpush(m, MMgetglobal(m, OFFSCCUR))) return MERRMEM;
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_COLLISION * 2))) return MERRMEM;
  if (MMpush(m, s)) return MERRMEM;
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_COLLISION * 2 + 1))) return MERRMEM;
 
  int b0 = MMfetch(m, OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR(node0->GetSceneNodeBody())), OFFOBJMAG);
  int b1 = MMfetch(m, OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR(node1->GetSceneNodeBody())), OFFOBJMAG);
 
  MMpush(m, b0);
  MMpush(m, b1);
 
  MMstore(m, pos, 0, FTOM(result->position.x));
  MMstore(m, pos, 1, FTOM(result->position.y));
  MMstore(m, pos, 2, FTOM(result->position.z));
 
  MMpush(m, PTOM(pos));
 
  MMstore(m, norm, 0, FTOM(result->normal.x));
  MMstore(m, norm, 1, FTOM(result->normal.y));
  MMstore(m, norm, 2, FTOM(result->normal.z));
  MMpush(m, PTOM(norm));
 
  MMstore(m, force, 0, FTOM(result->force.x));
  MMstore(m, force, 1, FTOM(result->force.y));
  MMstore(m, force, 2, FTOM(result->force.z));
  MMpush(m, PTOM(force));
  MMpush(m, FTOM(result->normalspeed));
 
  res = OBJcallreflex(m, 6);
  return res;
}
 
 
int getMaterialOverlapStartedCallback(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getMaterialOverlapStartedCallback\n");
#endif
 
  int obj, res;
  MCOLL* result = (MCOLL*)param;
  SNode* node0 = result->curScene->GetNode(result->node0);
  SNode* node1 = result->curScene->GetNode(result->node1);
 
  if ((node0 == 0) || (node1 == 0))
    return 0;
 
  // equal to OBJbeginreflex
  // is there a callback assigned to the object?
  obj = OBJfindTH(m, SO3PHYSICSMATERIALPAIR, id);
  if (obj == NIL)
    return -1;
 
  if (MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_OVERLAP_STARTED * 2) == NIL)
    return -1;
 
  // retrieve scene magma
  int s = MMfetch(m, OBJfindTH(m, SO3SCENETYPE, SCOL_PTR(result->curScene)), OFFOBJMAG);
 
  //equal to OBJpreparereflex but replace the object
  MMsetglobal(m, OFFSCCUR, MMfetch(m, obj, OFFOBJCHN));
  if (MMpush(m, MMgetglobal(m, OFFSCCUR))) return MERRMEM;
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_OVERLAP_STARTED * 2))) return MERRMEM;
  if (MMpush(m, s)) return MERRMEM;
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_OVERLAP_STARTED * 2 + 1))) return MERRMEM;
 
  if (node0->GetSceneNodeBody() == NULL)
  {
    MMpush(m, NIL);
    MMpush(m, NIL);
    MMpush(m, NIL);
    return 0;
  }
  if (node1->GetSceneNodeBody() == NULL)
  {
    MMpush(m, NIL);
    MMpush(m, NIL);
    MMpush(m, NIL);
    return 0;
  }
  int   b0 = 0;
  int   b1 = 0;
 
  b0 = MMfetch(m, OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR(node0->GetSceneNodeBody())), OFFOBJMAG);
  b1 = MMfetch(m, OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR(node1->GetSceneNodeBody())), OFFOBJMAG);
 
  MMpush(m, b0);
  MMpush(m, b1);
 
  res = OBJcallreflex(m, 2);
  return res;
}
 
 
int getMaterialOverlapEndedCallback(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getMaterialOverlapEndedCallback\n");
#endif
 
  int obj, res;
  MCOLL* result = (MCOLL*)param;
  SNode* node0 = result->curScene->GetNode(result->node0);
  SNode* node1 = result->curScene->GetNode(result->node1);
 
  if ((node0 == 0) || (node1 == 0))
    return 0;
 
  // equal to OBJbeginreflex
  // is there a callback assigned to the object?
  obj = OBJfindTH(m, SO3PHYSICSMATERIALPAIR, id);
  if (obj == NIL)
    return -1;
 
  if (MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_OVERLAP_ENDED * 2) == NIL)
    return -1;
 
  // retrieve scene magma
  int s = MMfetch(m, OBJfindTH(m, SO3SCENETYPE, SCOL_PTR(result->curScene)), OFFOBJMAG);
 
  //equal to OBJpreparereflex but replace the object
  MMsetglobal(m, OFFSCCUR, MMfetch(m, obj, OFFOBJCHN));
  if (MMpush(m, MMgetglobal(m, OFFSCCUR))) return MERRMEM;
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_OVERLAP_ENDED * 2))) return MERRMEM;
  if (MMpush(m, s)) return MERRMEM;
  if (MMpush(m, MMfetch(m, obj, OFFOBJREF0 + SO3_MATERIALPAIR_OVERLAP_ENDED * 2 + 1))) return MERRMEM;
 
  if (node0->GetSceneNodeBody() == NULL)
  {
    MMpush(m, NIL);
    MMpush(m, NIL);
    MMpush(m, NIL);
    return 0;
  }
  if (node1->GetSceneNodeBody() == NULL)
  {
    MMpush(m, NIL);
    MMpush(m, NIL);
    MMpush(m, NIL);
    return 0;
  }
  int   b0 = 0;
  int   b1 = 0;
 
  b0 = MMfetch(m, OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR(node0->GetSceneNodeBody())), OFFOBJMAG);
  b1 = MMfetch(m, OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR(node1->GetSceneNodeBody())), OFFOBJMAG);
 
  MMpush(m, b0);
  MMpush(m, b1);
 
  res = OBJcallreflex(m, 2);
  return res;
}
 
 
 
int SO3WorldSetFPS(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetFPS\n");
#endif
 
  int fps = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    if (fps > 0)
      scene->GetPhysicsWorld()->SetPhysicFPS(fps);
 
    MMset(m, 0, ITOM(1));
    return 0;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, 0);
    return 0;
  }
}
 
 
int SO3WorldGetFPS(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldGetFPS\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(scene->GetPhysicsWorld()->GetPhysicFPS()));
  return 0;
}
 
 
int SO3WorldSetSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetSize\n");
#endif
 
  int sizeMax = MTOP(MMpull(m));
  int sizeMin = MTOP(MMpull(m));
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    Ogre::Vector3 vectorMin;
    vectorMin.x = MTOF(MMfetch(m, sizeMin, 0));
    vectorMin.y = MTOF(MMfetch(m, sizeMin, 1));
    vectorMin.z = MTOF(MMfetch(m, sizeMin, 2));
 
    Ogre::Vector3 vectorMax;
    vectorMax.x = MTOF(MMfetch(m, sizeMax, 0));
    vectorMax.y = MTOF(MMfetch(m, sizeMax, 1));
    vectorMax.z = MTOF(MMfetch(m, sizeMax, 2));
    scene->GetPhysicsWorld()->SetPhysicWorldSize(vectorMin, vectorMax);
 
    return 0;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, 0);
    return 0;
  }
}
 
 
int SO3WorldSetFrictionModel(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetFrictionModel\n");
#endif
 
  MMpull(m);
  MMset(m, 0, NIL);
  return 0;
}
 
 
int SO3WorldGetFrictionModel(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldGetFrictionModel\n");
#endif
 
  MMset(m, 0, NIL);
  return 0;
}
 
 
int SO3WorldSetPlateformArchitecture(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetPlateformArchitecture\n");
#endif
 
  int mod = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  mod = MTOI(mod);
 
  // clamp to correct values
  if (mod < 0)
    mod = SO3_PA_DEFAULT;
  else if (mod > SO3_PA_BEST)
    mod = SO3_PA_BEST;
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    scene->GetPhysicsWorld()->SetPhysicPlatformArchitecture(mod);
    MMset(m, 0, ITOM(1));
    return 0;
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
}
 
 
int SO3WorldGetPlateformArchitecture(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldGetPlateformArchitecture\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    MMset(m, 0, ITOM(scene->GetPhysicsWorld()->GetPhysicPlatformArchitecture()));
    return 0;
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
}
 
 
int SO3WorldSetSolverModel(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetSolverModel\n");
#endif
 
  int mod = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  mod = MTOI(mod);
 
  // clamp to correct values
  if (mod < 0)
    mod = SO3_SM_ADAPTATIVE;
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    scene->GetPhysicsWorld()->SetPhysicSolverModel(mod);
    MMset(m, 0, ITOM(1));
    return 0;
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
}
 
 
int SO3WorldGetSolverModel(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldGetSolverModel\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(scene->GetPhysicsWorld()->GetPhysicSolverModel()));
  return 0;
}
 
 
int SO3WorldSetEnabled(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetEnabled\n");
#endif
 
  int booleen = MTOI(MMpull(m));
  int s = MMget(m, 0);
 
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (booleen == 0)
  {
    scene->GetPhysicsWorld()->SetPhysicWorldEnable(false);
  }
  else
  {
#ifdef SCOL_DEBUG
    MMechostr(MSKDEBUG, " > World is Set To Enable\n");
#endif
 
    scene->GetPhysicsWorld()->SetPhysicWorldEnable(true);
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WorldGetEnabled(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldGetEnabled\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (scene->GetPhysicsWorld()->GetPhysicWorldEnable())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
int SO3WorldReset(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldReset\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  scene->GetPhysicsWorld()->ResetPhysicWorld();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WorldSetBodiesInitialState(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetBodiesInitialState\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  scene->GetPhysicsWorld()->SetPhysicBodiesInitialState();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3BodySetInitialState(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetInitialState\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  body->GetParentNode()->StoreInitialPRS();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WorldShowLines(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldShowLines\n");
#endif
 
  int booleen = MTOI(MMpull(m));
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (booleen == 1)
    scene->GetPhysicsWorld()->SetPhysicDebugEnable(true);
  else
    scene->GetPhysicsWorld()->SetPhysicDebugEnable(false);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WorldSetGravity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldSetGravity\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vgravity = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  scene->GetPhysicsWorld()->SetPhysicGravity(vgravity);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WorldGetGravity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldGetGravity\n");
#endif
 
  int s = MMget(m, 0);
  if (s == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = scene->GetPhysicsWorld()->GetPhysicGravity();
 
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
int SO3BodyCreateBox(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateBox\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  SBody* body = 0;
  try
  {
    body = node->CreateBoxBody(vector);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateEllipsoid(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateEllipsoid\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  SBody* body = 0;
  try
  {
    body = node->CreateEllipsoidBody(vector);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateCapsule(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCapsule\n");
#endif
 
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  float height = MTOF(h);
  if (height == 0.0f)
    height = 0.001f;
 
  float radius = MTOF(rad);
  if (radius == 0.0f)
    radius = 0.001f;
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateCapsuleBody(radius, height);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateChamferCylinder(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateChamferCylinder\n");
#endif
 
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  // Create a SCOL Body
  SBody* body = 0;
 
  try
  {
    body = node->CreateChamferCylinderBody(MTOF(rad), MTOF(h));
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateCone(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCone\n");
#endif
 
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
 
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateConeBody(MTOF(rad), MTOF(h));
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateCylinder(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCylinder\n");
#endif
 
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateCylinderBody(MTOF(rad), MTOF(h));
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreatePyramid(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreatePyramid\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  SBody* body = 0;
  try
  {
    body = node->CreatePyramidBody(vector);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateBoxExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateBox\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int vec = MTOP(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
  int w = 0;
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  if (vector.x == 0.0f)
    vector.x = 0.001f;
 
  if (vector.y == 0.0f)
    vector.y = 0.001f;
 
  if (vector.z == 0.0f)
    vector.z = 0.001f;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  SBody* body = 0;
  try
  {
    body = node->CreateBoxBody(vector, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateEllipsoidExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateEllipsoid\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int vec = MTOP(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
  int w = 0;
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  if (vector.x == 0.0f)
    vector.x = 0.001f;
 
  if (vector.y == 0.0f)
    vector.y = 0.001f;
 
  if (vector.z == 0.0f)
    vector.z = 0.001f;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  SBody* body = 0;
  try
  {
    body = node->CreateEllipsoidBody(vector, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateCapsuleExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCapsule\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = 0;
  int y = 0;
  int z = 0;
  int w = 0;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  float height = MTOF(h);
  if (height == 0.0f)
    height = 0.001f;
 
  float radius = MTOF(rad);
  if (radius == 0.0f)
    radius = 0.001f;
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateCapsuleBody(radius, height, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateChamferCylinderExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateChamferCylinder\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = 0;
  int y = 0;
  int z = 0;
  int w = 0;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  float height = MTOF(h);
  if (height == 0.0f)
    height = 0.001f;
 
  float radius = MTOF(rad);
  if (radius == 0.0f)
    radius = 0.001f;
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateChamferCylinderBody(radius, height, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateConeExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCone\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
 
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = 0;
  int y = 0;
  int z = 0;
  int w = 0;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  float height = MTOF(h);
  if (height == 0.0f)
    height = 0.001f;
 
  float radius = MTOF(rad);
  if (radius == 0.0f)
    radius = 0.001f;
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateConeBody(radius, height, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateCylinderExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCylinder\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int h = MMpull(m);
  int rad = MMpull(m);
  int n = MMget(m, 0);
  if ((n == NIL) || (h == NIL) || (rad == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = 0;
  int y = 0;
  int z = 0;
  int w = 0;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  float height = MTOF(h);
  if (height == 0.0f)
    height = 0.001f;
 
  float radius = MTOF(rad);
  if (radius == 0.0f)
    radius = 0.001f;
 
  // Create a SCOL Body
  SBody* body = 0;
  try
  {
    body = node->CreateCylinderBody(radius, height, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreatePyramidExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreatePyramid\n");
#endif
 
  int q = MMpull(m);
  int pos = MMpull(m);
  int vec = MTOP(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
  int w = 0;
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  if (vector.x == 0.0f)
    vector.x = 0.001f;
 
  if (vector.y == 0.0f)
    vector.y = 0.001f;
 
  if (vector.z == 0.0f)
    vector.z = 0.001f;
 
  Ogre::Vector3 offset(Ogre::Vector3::ZERO);
  if (pos != NIL)
  {
    pos = MTOP(pos);
    x = MMfetch(m, pos, 0);
    y = MMfetch(m, pos, 1);
    z = MMfetch(m, pos, 2);
    offset = Ogre::Vector3((x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    x = MMfetch(m, q, 0);
    y = MMfetch(m, q, 1);
    z = MMfetch(m, q, 2);
    w = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((w == NIL) ? 0.0f : MTOF(w), (x == NIL) ? 0.0f : MTOF(x), (y == NIL) ? 0.0f : MTOF(y), (z == NIL) ? 0.0f : MTOF(z));
  };
 
  SBody* body = 0;
  try
  {
    body = node->CreatePyramidBody(vector, offset, quat);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKRUNTIME, "Cannot create body: %s\n", e.what());
  }
 
  if (body == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateCollisionTree(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateCollisionTree\n");
#endif
 
  int opti = MMpull(m);
  int n = MMget(m, 0);
  if (n == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool optimize = false;
  if (MTOI(opti) == 1)
    bool optimize = true;
 
  if ((node->GetNodeType() != SNode::ENTITY_TYPE_ID)/* && !node->GetAsStaticGeometry()*/)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  // Create a SCOL Body
  SBody* body = node->CreateTreeBody(optimize);
 
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateShape(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateShape\n");
#endif
 
  int toler = MMpull(m);
  int n = MMget(m, 0);
  if (n == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float tolerance = 0;
  if (toler != NIL)
    tolerance = MTOF(toler);
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SEntity* entity = static_cast<SEntity*> (node);
  if (!entity || !entity->getOgreEntityPointer())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  SBody* body = 0;
 
  // Create a SCOL Body
  try
  {
    body = node->CreateConvexHullBody(tolerance);
  }
  catch (Ogre::Exception)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
 
int SO3BodyCreateConcaveShape(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateConcaveShape\n");
#endif
 
  int toler = MMpull(m);
  int n = MMget(m, 0);
  if (n == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float tolerance = 0;
  if (toler != NIL)
    tolerance = MTOF(toler);
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SEntity* entity = static_cast<SEntity*> (node);
  if (!entity || !entity->getOgreEntityPointer())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Check if A body exist on node
  if (node->GetSceneNodeBody() != NULL)
  {
    OBJdelTH(m, SO3PHYSICBODY, SCOL_PTR(node->GetSceneNodeBody()));
  }
 
  SBody* body = 0;
 
  // Create a SCOL Body
  try
  {
    body = node->CreateConcaveHullBody(tolerance);
  }
  catch (Ogre::Exception)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createBody(m, node);
}
 
int SO3BodyGetShapeDefinition(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetShapeDefinition\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SShape* shape = body->GetShape();
  if (shape == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float tolerance = 0.0f;
  float radius = 0.0f;
  float height = 0.0f;
  Ogre::Vector3 size;
 
  SShape::ShapeType stype = shape->GetType();
 
  Ogre::Vector3 offsetpos = shape->GetBaseOffset();
  Ogre::Quaternion offsetquat = shape->GetBaseRotation();
  
  if (stype == SShape::SO3_BOX_COLLISION)
  {
    SShapeBox* bshape = static_cast<SShapeBox*>(shape);
    size = bshape->GetSize();
  }
  else if (stype == SShape::SO3_CAPSULE_COLLISION)
  {
    SShapeCapsule* bshape = static_cast<SShapeCapsule*>(shape);
    radius = bshape->GetRadius();
    height = bshape->GetHeight();
  }
  else if (stype == SShape::SO3_CHAMFERCYLINDRE_COLLISION)
  {
    SShapeChamferCylinder* bshape = static_cast<SShapeChamferCylinder*>(shape);
    radius = bshape->GetRadius();
    height = bshape->GetHeight();
  }
  else if (stype == SShape::SO3_CONE_COLLISION)
  {
    SShapeCone* bshape = static_cast<SShapeCone*>(shape);
    radius = bshape->GetRadius();
    height = bshape->GetHeight();
  }
  else if (stype == SShape::SO3_CYLINDER_COLLISION)
  {
    SShapeCylinder* bshape = static_cast<SShapeCylinder*>(shape);
    radius = bshape->GetRadius();
    height = bshape->GetHeight();
  }
  else if (stype == SShape::SO3_ELLIPSOID_COLLISION)
  {
    SShapeEllipsoid* bshape = static_cast<SShapeEllipsoid*>(shape);
    size = bshape->GetSize();
  }
  else if (stype == SShape::SO3_PYRAMID_COLLISION)
  {
    SShapePyramid* bshape = static_cast<SShapePyramid*>(shape);
    size = bshape->GetSize();
  }
  else if (stype == SShape::SO3_CONCAVE_COLLISION)
  {
    SShapeConcaveHull* bshape = static_cast<SShapeConcaveHull*>(shape);
    tolerance = bshape->GetTolerance();
  }
  else if (stype == SShape::SO3_SHAPE_COLLISION)
  {
    SShapeConvexHull* bshape = static_cast<SShapeConvexHull*>(shape);
    tolerance = bshape->GetTolerance();
  }
  /*
  else if (stype == SShape::SO3_TREE_COLLISION)
  {
    SShapeTree* bshape = static_cast<SShapeTree*>(shape);
  }
  */
 
  MMpush(m, ITOM((int)stype));
  MMpush(m, FTOM(tolerance));
 
  int trh = MMmalloc(m, 2, TYPETAB);
  if (trh == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, trh, 0, FTOM(radius));
  MMstore(m, trh, 1, FTOM(height));
  MMpush(m, PTOM(trh));
 
  int tsize = MMmalloc(m, 3, TYPETAB);
  if (tsize == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, tsize, 0, FTOM(size.x));
  MMstore(m, tsize, 1, FTOM(size.y));
  MMstore(m, tsize, 2, FTOM(size.z));
  MMpush(m, PTOM(tsize));
 
  int toffset = MMmalloc(m, 3, TYPETAB);
  if (toffset == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, toffset, 0, FTOM(offsetpos.x));
  MMstore(m, toffset, 1, FTOM(offsetpos.y));
  MMstore(m, toffset, 2, FTOM(offsetpos.z));
  MMpush(m, PTOM(toffset));
 
  int torientation = MMmalloc(m, 4, TYPETAB);
  if (torientation == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, torientation, 0, FTOM(offsetquat.x));
  MMstore(m, torientation, 1, FTOM(offsetquat.y));
  MMstore(m, torientation, 2, FTOM(offsetquat.z));
  MMstore(m, torientation, 3, FTOM(offsetquat.w));
  MMpush(m, PTOM(torientation));
 
  // FINAL TUPPLE 
  int result = MMmalloc(m, 6, TYPETAB);
  if (result == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, result, 5, MMpull(m));
  MMstore(m, result, 4, MMpull(m));
  MMstore(m, result, 3, MMpull(m));
  MMstore(m, result, 2, MMpull(m));
  MMstore(m, result, 1, MMpull(m));
  MMstore(m, result, 0, MMpull(m));
  MMset(m, 0, PTOM(result));
  return 0;
}
 
int SO3BodySetMass(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetMass\n");
#endif
 
  int mass = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (mass == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real omass = (Ogre::Real)MTOF(mass);
  body->SetMass(omass);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyCreateBasicJointUpVector(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCreateBasicJointUpVector\n");
#endif
 
  int vel = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vel == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector(MTOF(MMfetch(m, vel, 0)),
    MTOF(MMfetch(m, vel, 1)),
    MTOF(MMfetch(m, vel, 2)));
 
  body->SetUpJoint(vector);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyDestroyBasicJointUpVector(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyDestroyBasicJointUpVector\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  body->RemoveUpJoint();
 
  MMset(m, 0, 0);
  return 0;
}
 
 
int SO3BodySetForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetForce\n");
#endif
 
  int vec = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  vec = MTOP(vec);
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetForce(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyAddForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddForce\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetForce(body->GetForce() + vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetForce\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetForce();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodySetConstantForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetConstantForce\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetConstantForce(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyAddConstantForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddConstantForce\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->AddConstantForce(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetConstantForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetConstantForce\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetConstantForce();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
int SO3BodySetConstantTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetConstantTorque\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetConstantTorque(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyAddConstantTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddConstantTorque\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->AddConstantTorque(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetConstantTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetConstantTorque\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetConstantTorque();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodyAddGlobalForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddGlobalForce\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetGlobalForce(body->GetGlobalForce() + vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyAddLocalForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddLocalForce\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetLocalForce(body->GetLocalForce() + vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyAddTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddTorque\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetTorque(body->GetTorque() + vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetTorque\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetTorque(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetOmega(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetOmega\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetOmega(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetVelocity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetVelocity\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetVelocity(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyAddImpulse(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyAddImpulse\n");
#endif
 
  int pos = MTOP(MMpull(m));
  int deltav = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (pos == NIL) || (deltav == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, pos, 0);
  int y = MMfetch(m, pos, 1);
  int z = MMfetch(m, pos, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 position = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  int dx = MMfetch(m, deltav, 0);
  int dy = MMfetch(m, deltav, 1);
  int dz = MMfetch(m, deltav, 2);
 
  if ((dx == NIL) || (dy == NIL) || (dz == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 delta = Ogre::Vector3(MTOF(dx), MTOF(dy), MTOF(dz));
 
  body->AddImpulse(delta, position);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyMoveTo(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyMoveTo\n");
#endif
 
  int stif = MMpull(m);
  int src = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (src == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  src = MTOP(src);
  int x = MMfetch(m, src, 0);
  int y = MMfetch(m, src, 1);
  int z = MMfetch(m, src, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 dstpos = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  Ogre::Real stiffness = 1.0;
  if (stif != NIL)
    stiffness = MTOF(stif);
 
  if (stiffness <= 0.0f)
    stiffness = 0.000001f;
  else if (stiffness > 1.0f)
    stiffness = 1.0f;
 
  body->MoveToPosition(dstpos, stiffness);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyRotateTo(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyRotateTo\n");
#endif
 
  int stif = MMpull(m);
  int q = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (q == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Quaternion quat(Ogre::Quaternion::IDENTITY);
  if (q != NIL)
  {
    q = MTOP(q);
    int qx = MMfetch(m, q, 0);
    int qy = MMfetch(m, q, 1);
    int qz = MMfetch(m, q, 2);
    int qw = MMfetch(m, q, 3);
    quat = Ogre::Quaternion((qw == NIL) ? 0.0f : MTOF(qw), (qx == NIL) ? 0.0f : MTOF(qx), (qy == NIL) ? 0.0f : MTOF(qy), (qz == NIL) ? 0.0f : MTOF(qz));
  };
 
  Ogre::Real stiffness = 1.0;
  if (stif != NIL)
    stiffness = MTOF(stif);
 
  if (stiffness <= 0.0f)
    stiffness = 0.000001f;
  else if (stiffness > 1.0f)
    stiffness = 1.0f;
 
  body->RotateToOrientation(quat, stiffness);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
//TODO use an offset applied on each body update
int SO3BodySetPositionOrientation(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetPositionOrientation\n");
#endif
 
  int rot = MTOP(MMpull(m));
  int pos = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (pos == NIL) || (rot == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector(MTOF(MMfetch(m, pos, 0)),
    MTOF(MMfetch(m, pos, 1)),
    MTOF(MMfetch(m, pos, 2)));
 
  Ogre::Quaternion quat(MTOF(MMfetch(m, rot, 0)),
    MTOF(MMfetch(m, rot, 1)),
    MTOF(MMfetch(m, rot, 2)),
    MTOF(MMfetch(m, rot, 3)));
 
  body->SetMatrix(vector, quat);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetAngularDamping(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetAngularDamping\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetAngularDamping(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetCenterOfMass(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetCenterOfMass\n");
#endif
 
  int vec = MTOP(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetCenterOfMass(vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetMassMatrix(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetMassMatrix\n");
#endif
 
  int vec = MTOP(MMpull(m));
  float mass = MTOF(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vec == NIL) || (mass == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
 
  body->SetMassMatrix(mass, vector);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetAngularDamping(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetAngularDamping\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetAngularDamping();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodyGetOmega(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetOmega\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetOmega();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodySetLinearDamping(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetLinearDamping\n");
#endif
 
  int ang = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (ang == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  body->SetLinearDamping((Ogre::Real)MTOF(ang));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetAutoSleep(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetAutoSleep\n");
#endif
 
  int val = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool sleep = false;
  if ((val != NIL) && (MTOI(val) == 1))
    sleep = true;
 
  body->SetAutoSleep(sleep);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetType(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetType\n");
#endif
 
  int val = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  body->SetType(MTOI(val));
  MMset(m, 0, val);
  return 0;
}
 
int SO3BodySetIgnoreCollision(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetIgnoreCollision\n");
#endif
 
  int val = MMpull(m);
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool state = false;
  if (MTOI(val) >= 1)
    state = true;
 
  body->SetIgnoreCollision(state);
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
int SO3BodyGetIgnoreCollision(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetIgnoreCollision\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool state = body->GetIgnoreCollision();
 
  MMset(m, 0, state ? ITOM(1) : ITOM(0));
  return 0;
}
 
int SO3BodySetContiniousCollisionMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetContiniousCollisionMode\n");
#endif
 
  int val = MTOI(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool coll = false;
  if (val == 1)
    coll = true;
 
  body->SetContinuousCollisionMode(coll);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodySetFluid(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetFluid\n");
#endif
 
  int val = MTOI(MMpull(m));
  int bod = MMget(m, 0);
  if ((bod == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool fluid = false;
  if (val == 1)
    fluid = true;
 
  body->SetFluidState(fluid);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3BodyGetFluid(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetFluid\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool state = body->GetFluidState();
 
  MMset(m, 0, state ? ITOM(1) : ITOM(0));
  return 0;
}
 
 
int SO3BodySetFluidVolumeRatio(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetFluidVolumeRatio\n");
#endif
 
  int vol = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (vol == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float voltowater = MTOF(vol);
 
  body->SetFluidVolumeRatio(voltowater);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3BodyGetFluidVolumeRatio(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetFluidVolumeRatio\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(body->GetFluidWaterToVolumeRatio()));
  return 0;
}
 
int SO3BodyCalculateOffset(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyCalculateOffset\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->CalculateBodyOffset();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodyGetLinearDamping(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetLinearDamping\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float ld = body->GetLinearDamping();
  MMset(m, 0, FTOM(ld));
  return 0;
}
 
 
int SO3BodyGetInvMass(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetInvMass\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float mass;
  Ogre::Vector3 vector;
  body->GetInvMass(mass, vector);
  MMpush(m, FTOM(mass));
 
  int inertia = MMmalloc(m, 3, TYPETAB);
  if (inertia == NIL)
  {
    MMpull(m);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, inertia, 0, FTOM(vector.x));
  MMstore(m, inertia, 1, FTOM(vector.y));
  MMstore(m, inertia, 2, FTOM(vector.z));
  MMpush(m, PTOM(inertia));
 
  // FINAL TUPPLE 
  int result = MMmalloc(m, 2, TYPETAB);
  if (result == NIL)
  {
    MMpull(m);
    MMpull(m);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, result, 1, MMpull(m));
  MMstore(m, result, 0, MMpull(m));
  MMset(m, 0, PTOM(result));
  return 0;
}
 
 
int SO3BodyGetMassMatrix(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetMassMatrix\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float mass;
  Ogre::Vector3 vector;
  body->GetMassMatrix(mass, vector);
  MMpush(m, FTOM(mass));
 
  int inertia = MMmalloc(m, 3, TYPETAB);
  if (inertia == NIL)
  {
    MMpull(m);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, inertia, 0, FTOM(vector.x));
  MMstore(m, inertia, 1, FTOM(vector.y));
  MMstore(m, inertia, 2, FTOM(vector.z));
  MMpush(m, PTOM(inertia));
 
  // FINAL TUPPLE 
  int result = MMmalloc(m, 2, TYPETAB);
  if (result == NIL)
  {
    MMpull(m);
    MMpull(m);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, result, 1, MMpull(m));
  MMstore(m, result, 0, MMpull(m));
  MMset(m, 0, PTOM(result));
  return 0;
}
 
 
int SO3BodyGetAutoSleep(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetAutoSleep\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool sleep = body->GetAutoSleep();
 
  MMset(m, 0, ITOM(sleep ? 1 : 0));
  return 0;
}
 
 
int SO3BodyGetSleepingState(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetSleepingState\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool sleep = body->GetSleepState();
 
  MMset(m, 0, ITOM(sleep ? 1 : 0));
  return 0;
}
 
 
int SO3BodyGetType(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetType\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int ld = body->GetType();
  MMset(m, 0, ITOM(ld));
  return 0;
}
 
 
int SO3BodyGetContiniousCollisionMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetContiniousCollisionMode\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool coll = body->GetContinuousCollisionMode();
  MMset(m, 0, ITOM(coll ? 1 : 0));
  return 0;
}
 
 
int SO3BodyGetCenterOfMass(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetCenterOfMass\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody * body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetCenterOfMass();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodyGetVelocity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetVelocity\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = body->GetVelocity();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodyGetTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetTorque\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector = body->GetTorque();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vector.x)));
  MMstore(m, tuple, 1, FTOM((vector.y)));
  MMstore(m, tuple, 2, FTOM((vector.z)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3BodyGetPositionOrientation(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetPositionOrientation\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vector;
  Ogre::Quaternion quat;
  body->GetPositionOrientation(vector, quat);
 
  int position = MMmalloc(m, 3, TYPETAB);
  if (position == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, position, 0, FTOM(vector.x));
  MMstore(m, position, 1, FTOM(vector.y));
  MMstore(m, position, 2, FTOM(vector.z));
  MMpush(m, PTOM(position));
 
  int orientation = MMmalloc(m, 4, TYPETAB);
  if (orientation == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, orientation, 0, FTOM(quat.x));
  MMstore(m, orientation, 1, FTOM(quat.y));
  MMstore(m, orientation, 2, FTOM(quat.z));
  MMstore(m, orientation, 3, FTOM(quat.w));
  MMpush(m, PTOM(orientation));
 
  // FINAL TUPPLE 
  int result = MMmalloc(m, 2, TYPETAB);
  if (result == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, result, 1, MMpull(m));
  MMstore(m, result, 0, MMpull(m));
  MMset(m, 0, PTOM(result));
  return 0;
}
 
 
int SO3BodySetFreeze(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetFreeze\n");
#endif
 
  int val = MTOI(MMpull(m));
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (val > 0)
  {
    body->SetFreezeState(true);
  }
  else
  {
    body->SetFreezeState(false);
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetFreeze(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetFreeze\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (body->GetFreezeState())
    val = 1;
 
  MMset(m, 0, MTOI(val));
  return 0;
}
 
 
int SO3BodySetSimulation(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetSimulation\n");
#endif
 
  int val = MTOI(MMpull(m));
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (val > 0)
  {
    body->EnableSimulation(true);
  }
  else
  {
    body->EnableSimulation(false);
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetSimulation(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetSimulation\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (body->GetSimulationState())
    val = 1;
 
  MMset(m, 0, MTOI(val));
  return 0;
}
 
 
int SO3BodySetGravityEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetGravityEnable\n");
#endif
 
  int val = MTOI(MMpull(m));
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (val == 1)
  {
    body->SetGravityEnable(true);
  }
  else
  {
    body->SetGravityEnable(false);
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyGetGravityEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetGravityEnable\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (body->GetGravityEnable())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3BodyGetSceneNode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetSceneNode\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int c = OBJfindTH(m, SO3OBJTYPE, SCOL_PTR(body->GetParentNode()));
  if (c != NIL)
    c = MMfetch(m, c, OFFOBJMAG);
 
  MMset(m, 0, c);
  return 0;
}
 
 
int SO3BodyDestroy(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyDestroy\n");
#endif
 
  int body = MMget(m, 0);
  if (body == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SO3PHYSICBODY, body);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3BodyShowDebug(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyShowDebug\n");
#endif
 
  int istate = MMpull(m);
  int ibody = MMget(m, 0);
  if (ibody == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(ibody));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool state = false;
  if ((istate != NIL) && (MTOI(istate) > 0))
    state = true;
 
  body->ShowDebug(state);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3SceneNodeGetBody(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3SceneNodeGetBody\n");
#endif
 
  int n = MMget(m, 0);
  if (n == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!node->GetParentScene()->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetSceneNodeBody() == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int mbody = OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR node->GetSceneNodeBody());
  if (mbody != NIL)
    mbody = MMfetch(m, mbody, OFFOBJMAG);
 
  MMset(m, 0, mbody);
  return 0;
}
 
 
int SO3PhysicsRayCast(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsRayCast\n");
#endif
 
  int dist = MMpull(m);
  int dir = MTOP(MMpull(m));
  int src = MTOP(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (dir == NIL) || (src == NIL) || (dist == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x1 = MMfetch(m, src, 0);
  int y1 = MMfetch(m, src, 1);
  int z1 = MMfetch(m, src, 2);
 
  if ((x1 == NIL) || (y1 == NIL) || (z1 == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 srcVector(MTOF(x1), MTOF(y1), MTOF(z1));
 
  int x2 = MMfetch(m, dir, 0);
  int y2 = MMfetch(m, dir, 1);
  int z2 = MMfetch(m, dir, 2);
 
  if ((x2 == NIL) || (y2 == NIL) || (z2 == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 dirVector(MTOF(x2), MTOF(y2), MTOF(z2));
 
  Ogre::Real hitdist = 0;
  Ogre::Vector3 hitnormal = Ogre::Vector3::ZERO;
  SBody* hitbody = scene->GetPhysicsWorld()->PhysicsRayCast(srcVector, dirVector, MTOF(dist), hitdist, hitnormal);
 
  // no hit
  if (hitbody == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int mbody = OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR hitbody);
  if (mbody != NIL)
    mbody = MMfetch(m, mbody, OFFOBJMAG);
 
  // push body
  MMpush(m, mbody);
 
  //push dist
  MMpush(m, FTOM(hitdist));
 
  //normal tuple
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((hitnormal.x)));
  MMstore(m, tuple, 1, FTOM((hitnormal.y)));
  MMstore(m, tuple, 2, FTOM((hitnormal.z)));
  //push normal tuple
  MMpush(m, PTOM(tuple));
 
  // FINAL TUPPLE 
  int result = MMmalloc(m, 3, TYPETAB);
  if (result == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, result, 2, MMpull(m));
  MMstore(m, result, 1, MMpull(m));
  MMstore(m, result, 0, MMpull(m));
  //set result
  MMset(m, 0, PTOM(result));
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsRayCast: OK!\n");
#endif
  return 0;
}
 
int SO3PhysicsRayCastExt(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsRayCastExt\n");
#endif
 
  int dist = MMpull(m);
  int dir = MTOP(MMpull(m));
  int src = MTOP(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (dir == NIL) || (src == NIL) || (dist == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x1 = MMfetch(m, src, 0);
  int y1 = MMfetch(m, src, 1);
  int z1 = MMfetch(m, src, 2);
 
  if ((x1 == NIL) || (y1 == NIL) || (z1 == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 srcVector(MTOF(x1), MTOF(y1), MTOF(z1));
 
  int x2 = MMfetch(m, dir, 0);
  int y2 = MMfetch(m, dir, 1);
  int z2 = MMfetch(m, dir, 2);
 
  if ((x2 == NIL) || (y2 == NIL) || (z2 == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
  MMpull(m);
 
  Ogre::Vector3 dirVector(MTOF(x2), MTOF(y2), MTOF(z2));
  std::vector<MRAYINFO> hitbodies = scene->GetPhysicsWorld()->PhysicsRayCast(srcVector, dirVector, MTOF(dist));
 
  for (unsigned int i = 0; i < hitbodies.size(); i++)
  {
    MRAYINFO rinfo = hitbodies[i];
    int mbody = OBJfindTH(m, SO3PHYSICBODY, SCOL_PTR rinfo.body);
    if (mbody != NIL)
      mbody = MMfetch(m, mbody, OFFOBJMAG);
 
    // push body
    MMpush(m, mbody);
 
    //push dist
    MMpush(m, FTOM(rinfo.distance));
 
    //normal tuple
    int tuple = MMmalloc(m, 3, TYPETAB);
    if (tuple == NIL)
    {
      MMset(m, 0, NIL);
      return MERRMEM;
    }
 
    MMstore(m, tuple, 0, FTOM((rinfo.normal.x)));
    MMstore(m, tuple, 1, FTOM((rinfo.normal.y)));
    MMstore(m, tuple, 2, FTOM((rinfo.normal.z)));
    //push normal tuple
    MMpush(m, PTOM(tuple));
 
    // FINAL TUPPLE 
    int result = MMmalloc(m, 3, TYPETAB);
    if (result == NIL)
    {
      MMset(m, 0, NIL);
      return MERRMEM;
    }
 
    MMstore(m, result, 2, MMpull(m));
    MMstore(m, result, 1, MMpull(m));
    MMstore(m, result, 0, MMpull(m));
    //set result
    MMpush(m, PTOM(result));
  }
 
  if (MMpush(m, NIL))
    return MERRMEM;
 
  for (unsigned int j = 0; j < hitbodies.size(); j++)
  {
    if (MMpush(m, 2 * 2))
      return MERRMEM;
    if (int k = MBdeftab(m))
      return k;
  }
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsRayCast: OK!\n");
#endif
  return 0;
}
 
int SO3PhysicsContraintDestroy(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintDestroy\n");
#endif
 
  int joint = MMget(m, 0);
  if (joint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SO3PHYSICCONTRAINT, joint);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetCollisionState(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetCollisionState\n");
#endif
 
  int state = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetCollisionState bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool bstate = false;
  if (state != NIL && (MTOI(state) == 1))
    bstate = true;
 
  joint->SetCollisionState(bstate);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintGetCollisionState(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetCollisionState\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetCollisionState bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool bstate = joint->GetCollisionState();
 
  MMset(m, 0, bstate ? ITOM(1) : ITOM(0));
  return 0;
}
 
 
int SO3PhysicsContraintSetStiffness(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetStiffness\n");
#endif
 
  int val = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetStiffness bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real value = 1.0f;
  if (val != NIL)
    value = MTOF(val);
 
  joint->SetStiffness(value);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintGetStiffness(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetStiffness\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetStiffness bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real value = joint->GetStiffness();
 
  MMset(m, 0, FTOM(value));
  return 0;
}
 
 
int SO3PhysicsContraintCreateBallAndSocket(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateBallAndSocket\n");
#endif
 
  int limits = MMpull(m);
  int vec = MTOP(MMpull(m));
  int parentbod = MMpull(m);
  int sonbod = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL || sonbod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* sonBody = MMgetPointer<SBody*>(m, MTOP(sonbod));
  if (sonBody == NULL || sonBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateBallAndSocket bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* parentBody = 0;
  if (parentbod != NIL)
    parentBody = MMgetPointer<SBody*>(m, MTOP(parentbod));
 
  if (parentBody != NULL && parentBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateBallAndSocket bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 position = Ogre::Vector3::ZERO;
  if (vec != NIL)
  {
    int x = MMfetch(m, vec, 0);
    int y = MMfetch(m, vec, 1);
    int z = MMfetch(m, vec, 2);
 
    if ((x != NIL) && (y != NIL) && (z != NIL))
      position = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
  }
 
  bool useLimits = false;
  if (limits != NIL && (MTOI(limits) == 1))
    useLimits = true;
 
  SPhysicContraint* joint = 0;
  if (scene->GetPhysicsWorld())
  {
    joint = static_cast<SPhysicContraint*> (new SBallAndSocketContraint(scene, sonBody, parentBody, position, useLimits));
    scene->GetPhysicsWorld()->AddPhysicContraint(joint);
  }
 
  if (joint == NULL)
  {
    MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateBallAndSocket : failed to create joint\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createPhysicContraint(m, joint);
}
 
 
int SO3PhysicsContraintSetBallAndSocketLimits(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetBallAndSocketLimits\n");
#endif
 
  int mtwist = MMpull(m);
  int mitwist = MMpull(m);
  int mcone = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetBallAndSocketLimits bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian maxcone(0.0f);
  if (mcone != NIL)
    maxcone = MTOF(mcone);
 
  Ogre::Radian mintwist(0.0f);
  if (mitwist != NIL)
    mintwist = MTOF(mitwist);
 
  Ogre::Radian maxtwist(0.0f);
  if (mtwist != NIL)
    maxtwist = MTOF(mtwist);
 
  static_cast<SBallAndSocketContraint*>(joint)->SetLimits(maxcone, mintwist, maxtwist);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetBallAndSocketControlled(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetBallAndSocketControlled\n");
#endif
 
  int ctrl = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetBallAndSocketControlled bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool controlled = false;
  if (ctrl != NIL)
    controlled = (MTOI(ctrl) > 0) ? true : false;
 
  static_cast<SBallAndSocketContraint*>(joint)->SetControlledState(controlled);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetBallAndSocketAngularVelocity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetBallAndSocketAngularVelocity\n");
#endif
 
  int val = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetBallAndSocketAngularVelocity bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value = 0.0f;
  if (val != NIL)
    value = MTOF(val);
 
  static_cast<SBallAndSocketContraint*>(joint)->SetAngularVelocity(value);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetBallAndSocketYawAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetBallAndSocketYawAngle\n");
#endif
 
  int val = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetBallAndSocketYawAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value = 0.0f;
  if (val != NIL)
    value = MTOF(val);
 
  static_cast<SBallAndSocketContraint*>(joint)->SetYawAngle(value);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetBallAndSocketPitchAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetBallAndSocketPitchAngle\n");
#endif
 
  int val = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetBallAndSocketPitchAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value = 0.0f;
  if (val != NIL)
    value = MTOF(val);
 
  static_cast<SBallAndSocketContraint*>(joint)->SetPitchAngle(value);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetBallAndSocketRollAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetBallAndSocketRollAngle\n");
#endif
 
  int val = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetBallAndSocketRollAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float value = 0.0f;
  if (val != NIL)
    value = MTOF(val);
 
  static_cast<SBallAndSocketContraint*>(joint)->SetRollAngle(value);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintGetBallAndSocketAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetBallAndSocketAngle\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetBallAndSocketAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = static_cast<SBallAndSocketContraint*>(joint)->GetAngle();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
int SO3PhysicsContraintGetBallAndSocketOmega(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetBallAndSocketOmega\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetBallAndSocketOmega bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = static_cast<SBallAndSocketContraint*>(joint)->GetOmega();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
int SO3PhysicsContraintGetBallAndSocketForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetBallAndSocketForce\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_BALL_AND_SOCKET_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetBallAndSocketForce bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = static_cast<SBallAndSocketContraint*>(joint)->GetForce();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
int SO3PhysicsContraintCreateHinge(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateHinge\n");
#endif
 
  int limits = MMpull(m);
  int dir = MTOP(MMpull(m));
  int vec = MTOP(MMpull(m));
  int parentbod = MMpull(m);
  int sonbod = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL || sonbod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* sonBody = MMgetPointer<SBody*>(m, MTOP(sonbod));
  if (sonBody == NULL || sonBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateHinge bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* parentBody = 0;
  if (parentbod != NIL)
    parentBody = MMgetPointer<SBody*>(m, MTOP(parentbod));
 
  if (parentBody != NULL && parentBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateHinge bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 position = Ogre::Vector3::ZERO;
  if (vec != NIL)
  {
    int x = MMfetch(m, vec, 0);
    int y = MMfetch(m, vec, 1);
    int z = MMfetch(m, vec, 2);
 
    if ((x != NIL) && (y != NIL) && (z != NIL))
      position = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
  }
 
  Ogre::Vector3 direction = Ogre::Vector3(0.0f, 1.0f, 0.0f);
  if (dir != NIL)
  {
    int x = MMfetch(m, dir, 0);
    int y = MMfetch(m, dir, 1);
    int z = MMfetch(m, dir, 2);
 
    if ((x != NIL) && (y != NIL) && (z != NIL))
      direction = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
  }
 
  bool useLimits = false;
  if (limits != NIL && (MTOI(limits) == 1))
    useLimits = true;
 
  SPhysicContraint* joint = 0;
  if (scene->GetPhysicsWorld())
  {
    joint = static_cast<SPhysicContraint*> (new SHingeContraint(scene, sonBody, parentBody, position, direction, useLimits));
    scene->GetPhysicsWorld()->AddPhysicContraint(joint);
  }
 
  if (joint == NULL)
  {
    MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateHinge : failed to create joint\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createPhysicContraint(m, joint);
}
 
 
int SO3PhysicsContraintGetHingeAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetHingeAngle\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetHingeAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian value = static_cast<SHingeContraint*>(joint)->GetAngle();
  MMset(m, 0, FTOM(value.valueRadians()));
 
  return 0;
}
 
 
int SO3PhysicsContraintGetHingeOmega(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetHingeOmega\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetHingeOmega bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian value = static_cast<SHingeContraint*>(joint)->GetAngularVelocity();
  MMset(m, 0, FTOM(value.valueRadians()));
 
  return 0;
}
 
 
int SO3PhysicsContraintGetHingeForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetHingeForce\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetHingeForce bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = static_cast<SHingeContraint*>(joint)->GetForce();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
bool MaterialIDExists(SScene* scene, string testName, SMaterialID **result)
{
  if (!scene->GetPhysicsWorld())
    return false;
 
  SMaterialIDMap::iterator iMaterialIDSearched = scene->GetPhysicsWorld()->listOfMaterialID.find(testName);
  if (iMaterialIDSearched != scene->GetPhysicsWorld()->listOfMaterialID.end())
  {
    *result = iMaterialIDSearched->second;
    return true;
  }
  return false;
}
 
 
int SO3PhysicsContraintSetHingeLimits(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetHingeLimits\n");
#endif
 
  int maangle = MMpull(m);
  int miangle = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetHingeLimits bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian minangle(0.0f);
  if (miangle != NIL)
    minangle = MTOF(miangle);
 
  Ogre::Radian maxangle(0.0f);
  if (maangle != NIL)
    maxangle = MTOF(maangle);
 
  static_cast<SHingeContraint*>(joint)->SetLimits(minangle, maxangle);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintSetHingeMotorAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetHingeAngle\n");
#endif
 
  int mafrict = MMpull(m);
  int mifrict = MMpull(m);
  int ang = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetHingeMotorAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian angle(0.0f);
  if (ang != NIL)
    angle = MTOF(ang);
 
  Ogre::Real minFriction = 0.0f;
  if (mifrict != NIL)
    minFriction = MTOF(mifrict);
 
  Ogre::Real maxFriction = 0.0f;
  if (mafrict != NIL)
    maxFriction = MTOF(mafrict);
 
  static_cast<SHingeContraint*>(joint)->SetMotorAngle(angle, minFriction, maxFriction);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintSetHingeMotorOmega(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetHingeMotorOmega\n");
#endif
 
  int stre = MMpull(m);
  int ang = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetHingeMotorOmega bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian angle(0.0f);
  if (ang != NIL)
    angle = MTOF(ang);
 
  Ogre::Real strength = 0.5f;
  if (stre != NIL)
    strength = MTOF(stre);
 
  if (strength > 1.0f)
    strength = 1.0f;
 
  static_cast<SHingeContraint*>(joint)->SetMotorOmega(angle, strength);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetHingeTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetHingeTorque\n");
#endif
 
  int torq = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetHingeTorque bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real torque = 0.0f;
  if (torq != NIL)
    torque = MTOF(torq);
 
  static_cast<SHingeContraint*>(joint)->SetTorque(torque);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintSetHingeBrake(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetHingeBrake\n");
#endif
 
  int forc = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetHingeBrake bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real force = -1.0f;
  if (forc != NIL)
    force = MTOF(forc);
 
  static_cast<SHingeContraint*>(joint)->SetBrake(force);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetHingeMotorEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetHingeMotorEnable\n");
#endif
 
  int state = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_HINGE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetHingeMotorEnable bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool enable = false;
  if ((state != NIL) && (MTOI(state) == 1))
    enable = true;
 
  static_cast<SHingeContraint*>(joint)->UseMotor(enable);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintCreateSlider(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateSlider\n");
#endif
 
  int spring = MMpull(m);
  int limits = MMpull(m);
  int dir = MTOP(MMpull(m));
  int vec = MTOP(MMpull(m));
  int parentbod = MMpull(m);
  int sonbod = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL || sonbod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* sonBody = MMgetPointer<SBody*>(m, MTOP(sonbod));
  if (sonBody == NULL || sonBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateSlider bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* parentBody = 0;
  if (parentbod != NIL)
    parentBody = MMgetPointer<SBody*>(m, MTOP(parentbod));
 
  if (parentBody != NULL && parentBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateSlider bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 position = Ogre::Vector3::ZERO;
  if (vec != NIL)
  {
    int x = MMfetch(m, vec, 0);
    int y = MMfetch(m, vec, 1);
    int z = MMfetch(m, vec, 2);
 
    if ((x != NIL) && (y != NIL) && (z != NIL))
      position = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
  }
 
  Ogre::Vector3 direction = Ogre::Vector3(0.0f, 1.0f, 0.0f);
  if (dir != NIL)
  {
    int x = MMfetch(m, dir, 0);
    int y = MMfetch(m, dir, 1);
    int z = MMfetch(m, dir, 2);
 
    if ((x != NIL) && (y != NIL) && (z != NIL))
      direction = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
  }
  if (direction == Ogre::Vector3::ZERO)
    direction = Ogre::Vector3::UNIT_Y;
 
  bool useLimits = false;
  if (limits != NIL && (MTOI(limits) == 1))
    useLimits = true;
 
  bool useSpring = false;
  if (spring != NIL && (MTOI(spring) == 1))
    useSpring = true;
 
  SPhysicContraint* joint = 0;
  if (scene->GetPhysicsWorld())
  {
    joint = static_cast<SPhysicContraint*> (new SSliderContraint(scene, sonBody, parentBody, position, direction, useLimits, useSpring));
    scene->GetPhysicsWorld()->AddPhysicContraint(joint);
  }
 
  if (joint == NULL)
  {
    MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateSlider : failed to create joint\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createPhysicContraint(m, joint);
}
 
 
int SO3PhysicsContraintGetSliderVelocity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetSliderVelocity\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetSliderVelocity bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real value = static_cast<SSliderContraint*>(joint)->GetVelocity();
  MMset(m, 0, FTOM(value));
 
  return 0;
}
 
 
int SO3PhysicsContraintGetSliderForce(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetSliderForce\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetSliderForce bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 vec = static_cast<SSliderContraint*>(joint)->GetForce();
  int tuple = MMmalloc(m, 3, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, FTOM((vec.x)));
  MMstore(m, tuple, 1, FTOM((vec.y)));
  MMstore(m, tuple, 2, FTOM((vec.z)));
  MMset(m, 0, PTOM(tuple));
 
  return 0;
}
 
 
int SO3PhysicsContraintGetSliderPosition(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetSliderPosition\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetSliderPosition bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real pos = static_cast<SSliderContraint*>(joint)->GetDistance();
  MMset(m, 0, FTOM(pos));
 
  return 0;
}
 
 
int SO3PhysicsContraintSetSliderLimits(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetSliderLimits\n");
#endif
 
  int madist = MMpull(m);
  int midist = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetSliderLimits bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real mindist(0.0f);
  if (midist != NIL)
    mindist = MTOF(midist);
 
  Ogre::Real maxdist(0.0f);
  if (madist != NIL)
    maxdist = MTOF(madist);
 
  static_cast<SSliderContraint*>(joint)->SetLimits(mindist, maxdist);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetSliderSpring(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetSliderSpring\n");
#endif
 
  int spdamp = MMpull(m);
  int spstrength = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetSliderSpring bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real springStrength(0.0f);
  if (spstrength != NIL)
    springStrength = MTOF(spstrength);
 
  Ogre::Real springDamping(0.0f);
  if (spdamp != NIL)
    springDamping = MTOF(spdamp);
 
  static_cast<SSliderContraint*>(joint)->SetSpring(springStrength, springDamping);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetSliderFriction(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetSliderFriction\n");
#endif
 
  int sfriction = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetSliderFriction bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real friction(0.0f);
  if (sfriction != NIL)
    friction = MTOF(sfriction);
 
  static_cast<SSliderContraint*>(joint)->SetFriction(friction);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintSetSliderMotorEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetSliderMotorEnable\n");
#endif
 
  int state = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetSliderMotorEnable bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool enable = false;
  if ((state != NIL) && (MTOI(state) == 1))
    enable = true;
 
  static_cast<SSliderContraint*>(joint)->UseMotor(enable);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3PhysicsContraintSetSliderMotorVelocity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetSliderMotorVelocity\n");
#endif
 
  int stre = MMpull(m);
  int velo = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_SLIDER_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetSliderMotorVelocity bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real velocity(0.0f);
  if (velo != NIL)
    velocity = MTOF(velo);
 
  Ogre::Real strength = 0.5f;
  if (stre != NIL)
    strength = MTOF(stre);
 
  if (strength > 1.0f)
    strength = 1.0f;
 
  static_cast<SSliderContraint*>(joint)->SetMotorVelocity(velocity, strength);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintCreateVehicle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateVehicle\n");
#endif
 
  int sonbod = MMpull(m);
  int s = MMget(m, 0);
  if (s == NIL || sonbod == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* sonBody = MMgetPointer<SBody*>(m, MTOP(sonbod));
  if (sonBody == NULL || sonBody->GetParentNode()->GetParentScene() != scene)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintCreateVehicle bad body to create joint or the body is not in the same scene.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = 0;
  if (scene->GetPhysicsWorld())
  {
    joint = static_cast<SPhysicContraint*>(new SVehicleContraint(scene, sonBody));
    scene->GetPhysicsWorld()->AddPhysicContraint(joint);
  }
 
  if (joint == NULL)
  {
    MMechostr(MSKDEBUG, "SO3PhysicsContraintCreateVehicle : failed to create joint\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last parameter
  MMpull(m);
  return createPhysicContraint(m, joint);
}
 
 
int SO3PhysicsContraintAddVehicleTire(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintAddVehicleTire\n");
#endif
 
  int idriving = MMpull(m);
  int isteer = MMpull(m);
  int isusshock = MMpull(m);
  int isusspring = MMpull(m);
  int isuslength = MMpull(m);
  int ifriction = MMpull(m);
  int iwidth = MMpull(m);
  int iradius = MMpull(m);
  int imass = MMpull(m);
  int inode = MMpull(m);
  int mjoint = MMget(m, 0);
  if ((mjoint == NIL) || (inode == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintAddVehicleTire bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(inode));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real mass(1.0f);
  if (imass != NIL)
    mass = MTOF(imass);
 
  Ogre::Real radius(0.0f);
  if (iradius != NIL)
    radius = MTOF(iradius);
 
  Ogre::Real width(0.1f);
  if (iwidth != NIL)
    width = MTOF(iwidth);
 
  Ogre::Real friction(1.0f);
  if (ifriction != NIL)
    friction = MTOF(ifriction);
 
  Ogre::Real suslength(0.0f);
  if (isuslength != NIL)
    suslength = MTOF(isuslength);
 
  Ogre::Real susspring(0.0f);
  if (isusspring != NIL)
    susspring = MTOF(isusspring);
 
  Ogre::Real susshock(0.0f);
  if (isusshock != NIL)
    susshock = MTOF(isusshock);
 
  bool bsteer = false;
  if ((isteer != NIL) && (MTOI(isteer) == 1))
    bsteer = true;
 
  bool bdriving = false;
  if ((idriving != NIL) && (MTOI(idriving) == 1))
    bdriving = true;
 
  static_cast<SVehicleContraint*>(joint)->AddTire(node, mass, radius, width, friction, suslength, susspring, susshock, bsteer, bdriving);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintGetVehicleSpeed(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetVehicleSpeed\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetVehicleSpeed bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real speed = static_cast<SVehicleContraint*>(joint)->GetSpeed();
  MMset(m, 0, FTOM(speed));
 
  return 0;
}
 
 
int SO3PhysicsContraintSetVehicleSteerAngle(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetVehicleSteerAngle\n");
#endif
 
  int iangle = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetVehicleSteerAngle bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian angle(0.0f);
  if (iangle != NIL)
    angle = Ogre::Radian(MTOF(iangle));
 
  static_cast<SVehicleContraint*>(joint)->SetSteerAngle(angle);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetVehicleDrivingTorque(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetVehicleDrivingTorque\n");
#endif
 
  int itorque = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetVehicleDrivingTorque bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Radian torque(0.0f);
  if (itorque != NIL)
    torque = Ogre::Radian(MTOF(itorque));
 
  static_cast<SVehicleContraint*>(joint)->SetDrivingTorque(torque);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintSetVehicleBrake(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintSetVehicleBrake\n");
#endif
 
  int ibrake = MMpull(m);
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintSetVehicleBrake bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Real brake(0.0f);
  if (ibrake != NIL)
    brake = MTOF(ibrake);
 
  static_cast<SVehicleContraint*>(joint)->SetBrake(brake);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsContraintGetVehicleOnAir(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetVehicleOnAir\n");
#endif
 
  int mjoint = MMget(m, 0);
  if (mjoint == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetVehicleOnAir bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(static_cast<SVehicleContraint*>(joint)->GetVehicleOnAir() ? 1 : 0));
  return 0;
}
 
 
int SO3PhysicsContraintGetVehicleTireAngularVelocity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetVehicleTireAngularVelocity\n");
#endif
 
  int inode = MMpull(m);
  int mjoint = MMget(m, 0);
  if ((mjoint == NIL) || (inode == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetVehicleTireAngularVelocity bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(inode));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(static_cast<SVehicleContraint*>(joint)->GetTireAngularVelocity(node)));
  return 0;
}
 
 
int SO3PhysicsContraintGetVehicleTireOnAir(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsContraintGetVehicleTireOnAir\n");
#endif
 
  int inode = MMpull(m);
  int mjoint = MMget(m, 0);
  if ((mjoint == NIL) || (inode == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SPhysicContraint* joint = MMgetPointer<SPhysicContraint*>(m, MTOP(mjoint));
  if (joint == NULL || joint->GetType() != SPhysicContraint::SO3_VEHICLE_CONTRAINT)
  {
    MMechostr(MSKRUNTIME, "SO3PhysicsContraintGetVehicleTireOnAir bad joint type.\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(inode));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int state = (static_cast<SVehicleContraint*>(joint)->GetTireOnAir(node)) ? 1 : 0;
  MMset(m, 0, ITOM(state));
  return 0;
}
 
 
SMaterialPair* getMaterialPairByWorld(SPhysicWorld* world, int ID1, int ID2)
{
  SMaterialPairMap::iterator iMaterialPairList = world->listOfPhysicsMaterialPair.begin();
  while (iMaterialPairList != world->listOfPhysicsMaterialPair.end())
  {
    if (((*iMaterialPairList)->getID1() == ID1 && (*iMaterialPairList)->getID2() == ID2) || ((*iMaterialPairList)->getID2() == ID1 && (*iMaterialPairList)->getID1() == ID2))
      return (*iMaterialPairList);
 
    iMaterialPairList++;
  }
 
  return NULL;
}
 
 
int SO3BodySetMaterial(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetMaterial\n");
#endif
 
  int mat = MMpull(m);
  int bod = MMget(m, 0);
  if ((bod == NIL) || (mat == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID = MMgetPointer<SMaterialID*>(m, MTOP(mat));
  if (matID == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  body->SetMaterialID(matID);
  MMset(m, 0, ITOM(1));
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodySetMaterial: OK!\n");
#endif
  return 0;
}
 
 
int SO3BodyGetMaterial(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3BodyGetMaterial\n");
#endif
 
  int bod = MMget(m, 0);
  if (bod == NIL)
  {
    MMechostr(MSKDEBUG, "SO3BodyGetMaterial: one of the parameters is NIL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SBody* body = MMgetPointer<SBody*>(m, MTOP(bod));
  if (body == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  const SMaterialID* matID = body->GetMaterial();
  if (matID == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int mat = OBJfindTH(m, SO3PHYSICSMATERIALTYPE, SCOL_PTR(matID));
  if (mat != NIL)
    mat = MMfetch(m, mat, OFFOBJMAG);
 
  MMset(m, 0, mat);
  return 0;
}
 
 
//TODO test mat1 and mat2 name with "" and trim
int SO3PhysicsMaterialCreate(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialCreate\n");
#endif
 
  int nam = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (nam == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  string name = MMstartstr(m, MTOP(nam));
  if (name.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  //Check if materialID already Exist
  SMaterialID* matID;
  if (MaterialIDExists(scene, name, &matID))
  {
    int a = OBJfindTH(m, SO3PHYSICSMATERIALTYPE, SCOL_PTR(matID));
    if (a != NIL)
      a = MMfetch(m, a, OFFOBJMAG);
 
    MMset(m, 0, a);
    return 0;
  }
 
  //remove last param
  MMpull(m);
 
  // Create Material ID 
  matID = scene->GetPhysicsWorld()->CreatePhysicMaterialID(name);
 
  // Creating Materials Pair With each Other Material ID in the Scene
  SMaterialIDMap::iterator iMaterialIDList = scene->GetPhysicsWorld()->listOfMaterialID.begin();
  while (iMaterialIDList != scene->GetPhysicsWorld()->listOfMaterialID.end())
  {
    SMaterialPair* matPair = scene->GetPhysicsWorld()->CreatePhysicMaterialPair(matID, iMaterialIDList->second);
    createMaterialPair(m, matPair, scene);
 
    //restore the stak state
    MMpull(m);
 
    iMaterialIDList++;
  }
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialCreate : OK!\n");
#endif
  return createMaterialID(m, matID, scene);
}
 
 
int SO3PhysicsMaterialDestroy(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialDestroy\n");
#endif
 
  int mat = MMget(m, 0);
  if (mat == NIL)
  {
    MMset(m, 0, 0);
    return 0;
  }
 
  // Destruction of the scol Object
  OBJdelTM(m, SO3PHYSICSMATERIALTYPE, mat);
 
  MMset(m, 0, ITOM(1));
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialDestroy : OK!\n");
#endif
  return 0;
}
 
 
int SO3PhysicsGetMaterial(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsGetMaterial\n");
#endif
 
  int name = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (name == NIL))
  {
    MMechostr(MSKDEBUG, "SO3PhysicsGetMaterial: one of the parameters is NIL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  string matname = MMstartstr(m, MTOP(name));
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "Material Name : %s \n", matname.c_str());
#endif
 
  if (matname.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID = NULL;
  SMaterialIDMap::iterator iMaterialIDSearched = scene->GetPhysicsWorld()->listOfMaterialID.find(matname);
  if (iMaterialIDSearched != scene->GetPhysicsWorld()->listOfMaterialID.end())
    matID = iMaterialIDSearched->second;
 
  if (matID == NULL)
  {
    MMechostr(MSKDEBUG, "Physic material not found %s\n", matname.c_str());
    MMset(m, 0, NIL);
    return 0;
  }
 
  int mat = OBJfindTH(m, SO3PHYSICSMATERIALTYPE, SCOL_PTR(matID));
  if (mat != NIL)
    mat = MMfetch(m, mat, OFFOBJMAG);
 
  MMset(m, 0, mat);
  return 0;
}
 
 
int SO3PhysicsGetMaterialName(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsGetMaterialName\n");
#endif
 
  int mat = MMget(m, 0);
  if (mat == NIL)
  {
    MMechostr(MSKDEBUG, "SO3PhysicsGetMaterialName: one of the parameters is NIL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID = MMgetPointer<SMaterialID*>(m, MTOP(mat));
  if (matID == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  Mpushstrbloc(m, (char*)matID->GetName().c_str());
  return 0;
}
 
int SO3PhysicsMaterialSetSurfaceThickness(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetSurfaceThickness\n");
#endif
 
  int val = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMget(m, 0);
  if ((mat1 == NIL) || (mat2 == NIL) || (val == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting Material Pair Associated in the Scene
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  matPair->SetDefaultSurfaceThickness((Ogre::Real)(MTOF(val)));
  MMset(m, 0, ITOM(1));
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetSurfaceThickness : OK!\n");
#endif
  return 0;
}
 
 
int SO3PhysicsMaterialSetDefaultElasticity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetDefaultElasticity\n");
#endif
 
  int val = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMget(m, 0);
  if ((mat1 == NIL) || (mat2 == NIL) || (val == NIL))
  {
    MMechostr(MSKDEBUG, "One of Paramter is NIL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMechostr(MSKDEBUG, "MatID1 is NULL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMechostr(MSKDEBUG, "MatID1 is NULL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting Material Pair Associated in the Scene
  SMaterialPair* matPair;
  matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMechostr(MSKDEBUG, "MAtPair is NULL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
  matPair->SetDefaultElasticity((Ogre::Real)(MTOF(val)));
 
  MMset(m, 0, ITOM(1));
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetDefaultElasticity : OK!\n");
#endif
  return 0;
}
 
 
int SO3PhysicsMaterialSetDefaultFriction(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetDefaultFriction\n");
#endif
 
  int val2 = MMpull(m);
  int val1 = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMget(m, 0);
  if ((mat1 == NIL) || (mat2 == NIL) || (val1 == NIL) || (val2 == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting Material Pair Associated in the Scene
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  matPair->SetDefaultFriction((Ogre::Real)(MTOF(val1)), (Ogre::Real)(MTOF(val2)));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsMaterialSetDefaultSoftness(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetDefaultSoftness\n");
#endif
 
  int val = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMget(m, 0);
  if ((mat1 == NIL) || (mat2 == NIL) || (val == NIL))
  {
    MMechostr(MSKDEBUG, "One of Paramter is NIL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting Material Pair Associated in the Scene
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  matPair->SetDefaultSoftness((Ogre::Real)(MTOF(val)));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsMaterialSetDefaultCollidable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetDefaultCollidable\n");
#endif
 
  int val = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMget(m, 0);
  if ((mat1 == NIL) || (mat2 == NIL) || (val == NIL))
  {
    MMechostr(MSKDEBUG, "One of Paramter is NIL!!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Getting Material Pair Associated in the Scene
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool coll = false;
  if (MTOI(val) == 1)
    coll = true;
 
  matPair->SetDefaultCollidable(coll);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3PhysicsMaterialSetContiniousCollisionMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3PhysicsMaterialSetContiniousCollisionMode\n");
#endif
  int val = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMget(m, 0);
 
  MMset(m, 0, NIL);
  return 0;
}
 
int SO3WorldApplyImpulsePoint(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WorldApplyImpulsePoint\n");
#endif
 
  int istrength = MMpull(m);
  int iradius = MMpull(m);
  int vec = MTOP(MMpull(m));
  int s = MMget(m, 0);
  if ((s == NIL) || (vec == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int x = MMfetch(m, vec, 0);
  int y = MMfetch(m, vec, 1);
  int z = MMfetch(m, vec, 2);
 
  if ((x == NIL) || (y == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!scene->GetPhysicsWorld())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 position = Ogre::Vector3(MTOF(x), MTOF(y), MTOF(z));
  Ogre::Real radius = 1.0f;
  if (iradius != NIL)
    radius = MTOF(iradius);
 
  Ogre::Real strength = 1.0f;
  if (istrength != NIL)
    strength = MTOF(istrength);
 
  scene->GetPhysicsWorld()->ApplyImpulsePoint(position, radius, strength);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3CbMaterialCollision(mmachine m)
{
#if     SO3_DEBUG == 1
  MMechostr(MSKDEBUG, "SO3CbMaterialCollision\n");
#endif
  int k;
 
  int pUser = MMpull(m);
  int pCbk = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMpull(m);
 
  // check mat1
  if (mat1 == NIL)
  {
    MMechostr(0, "SO3CbMaterialCollision error : mat1 is nil...\n");
    MMpush(m, NIL);
    return 0;
  }
 
  // check mat2
  if (mat2 == NIL)
  {
    MMechostr(0, "SO3CbMaterialCollision error : mat2 is nil...\n");
    MMpush(m, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  // Getting MaterialPair associated
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  if (pCbk == NIL)
  {
    matPair->SetContactCallbackActivated(false);
  }
  else
  {
    matPair->SetContactCallbackActivated(true);
  }
 
  int ob = MMfetch(m, OBJfindTH(m, SO3PHYSICSMATERIALPAIR, SCOL_PTR(matPair)), OFFOBJMAG);
  if (ob == NIL)
  {
    matPair->SetContactCallbackActivated(false);
    MMpush(m, NIL);
    return 0;
  }
 
  /*
   2 : object
   1 : cbfun
   0 : argument u0
   */
  MMpush(m, ob);
  MMpush(m, pCbk);
  MMpush(m, pUser);
 
  k = OBJaddreflex(m, SO3PHYSICSMATERIALPAIR, SO3_MATERIALPAIR_COLLISION);
 
  MMset(m, 0, ITOM(1));
 
#if     SO3_DEBUG == 1
  MMechostr(MSKDEBUG, "SO3CbMaterialCollision : OK!\n");
#endif
  return 0;
}
 
 
int SO3CbMaterialOverlapStarted(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3CbMaterialOverlapStarted\n");
#endif
 
  int k;
  int pUser = MMpull(m);
  int pCbk = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMpull(m);
 
  // check mat1
  if (mat1 == NIL)
  {
    MMechostr(0, "SO3CbMaterialOverlapStarted error : mat1 is nil...\n");
    MMpush(m, NIL);
    return 0;
  }
 
  // check mat2
  if (mat2 == NIL)
  {
    MMechostr(0, "SO3CbMaterialOverlapStarted error : mat2 is nil...\n");
    MMpush(m, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  // Getting MaterialPair associated
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  if (pCbk == NIL)
  {
    matPair->SetOverlapStartedCallbackActivated(false);
  }
  else
  {
    matPair->SetOverlapStartedCallbackActivated(true);
  }
 
  int ob = MMfetch(m, OBJfindTH(m, SO3PHYSICSMATERIALPAIR, SCOL_PTR(matPair)), OFFOBJMAG);
  if (ob == NIL)
  {
    matPair->SetOverlapStartedCallbackActivated(false);
    MMpush(m, NIL);
    return 0;
  }
 
  /*
   2 : object
   1 : cbfun
   0 : argument u0
   */
  MMpush(m, ob);
  MMpush(m, pCbk);
  MMpush(m, pUser);
 
  k = OBJaddreflex(m, SO3PHYSICSMATERIALPAIR, SO3_MATERIALPAIR_OVERLAP_STARTED);
 
  MMset(m, 0, ITOM(1));
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3CbMaterialOverlapStarted : OK!\n");
#endif
  return 0;
}
 
 
int SO3CbMaterialOverlapEnded(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3CbMaterialOverlapEnded\n");
#endif
 
  int k;
  int pUser = MMpull(m);
  int pCbk = MMpull(m);
  int mat2 = MMpull(m);
  int mat1 = MMpull(m);
 
  // check mat1
  if (mat1 == NIL)
  {
    MMechostr(0, "SO3CbMaterialOverlapStarted error : mat1 is nil...\n");
    MMpush(m, NIL);
    return 0;
  }
 
  // check mat2
  if (mat2 == NIL)
  {
    MMechostr(0, "SO3CbMaterialOverlapStarted error : mat2 is nil...\n");
    MMpush(m, NIL);
    return 0;
  }
 
  SMaterialID* matID1 = MMgetPointer<SMaterialID*>(m, MTOP(mat1));
  if (matID1 == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SMaterialID* matID2 = MMgetPointer<SMaterialID*>(m, MTOP(mat2));
  if (matID2 == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  // Getting MaterialPair associated
  SMaterialPair* matPair = getMaterialPairByWorld(matID1->GetParentWorld(), matID1->getID(), matID2->getID());
  if (matPair == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  if (pCbk == NIL)
  {
    matPair->SetOverlapEndedCallbackActivated(false);
  }
  else
  {
    matPair->SetOverlapEndedCallbackActivated(true);
  }
 
  int ob = MMfetch(m, OBJfindTH(m, SO3PHYSICSMATERIALPAIR, SCOL_PTR(matPair)), OFFOBJMAG);
  if (ob == NIL)
  {
    matPair->SetOverlapEndedCallbackActivated(false);
    MMpush(m, NIL);
    return 0;
  }
 
  /*
   2 : object
   1 : cbfun
   0 : argument u0
   */
  MMpush(m, ob);
  MMpush(m, pCbk);
  MMpush(m, pUser);
 
  k = OBJaddreflex(m, SO3PHYSICSMATERIALPAIR, SO3_MATERIALPAIR_OVERLAP_ENDED);
 
  MMset(m, 0, ITOM(1));
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3CbMaterialOverlapEnded : OK!\n");
#endif
  return 0;
}
 
 
int SO3CbBodyLeaveWorld(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3CbBodyLeaveWorld\n");
#endif
  MMpull(m);
  MMpull(m);
  MMset(m, 0, NIL);
 
  return 0;
  //return OBJaddreflex(m, SO3PHYSICBODY, SO3_BODY_LEAVE_WORLD);
}
 
NativeDefinition natSO3Phys[] = {
  { "SO3_TYPE_BODY_BOX",                                    TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_BOX_COLLISION)            },
  { "SO3_TYPE_BODY_CONE",                                   TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_CONE_COLLISION)           },
  { "SO3_TYPE_BODY_ELLIPSOID",                              TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_ELLIPSOID_COLLISION)      },
  { "SO3_TYPE_BODY_CAPSULE",                                TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_CAPSULE_COLLISION)        },
  { "SO3_TYPE_BODY_CYLINDER",                               TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_CYLINDER_COLLISION)       },
  { "SO3_TYPE_BODY_COMPOUND",                               TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_COMPOUND_COLLISION)       },
  { "SO3_TYPE_BODY_CHAMFERCYLINDRE",                        TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_CHAMFERCYLINDRE_COLLISION)},
  { "SO3_TYPE_BODY_PYRAMID",                                TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_PYRAMID_COLLISION)        },
  { "SO3_TYPE_BODY_SHAPE",                                  TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_SHAPE_COLLISION)          },
  { "SO3_TYPE_BODY_CONCAVE",                                TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_CONCAVE_COLLISION)        },
  { "SO3_TYPE_BODY_TREE",                                   TYPVAR, "I",                                                                                                                            SCOL_TYPTYPE(SShape::SO3_TREE_COLLISION)           },
  { "SO3WorldSetFPS",                                        2,  "fun [SO3_SCENE I] I",                                                                                                                                                                               SO3WorldSetFPS                                     },
  { "SO3WorldSetSize",                                       3,  "fun [SO3_SCENE [F F F] [F F F]] I",                                                                                                                                           SO3WorldSetSize                                    },
  { "SO3WorldGetFPS",                                        1,  "fun [SO3_SCENE] I",                                                                                                                                                                                 SO3WorldGetFPS                                     },
  { "SO3WorldSetFrictionModel",                              2,  "fun [SO3_SCENE I] I",                                                                                                                                                                                     SO3WorldSetFrictionModel                           },
  { "SO3WorldGetFrictionModel",                              1,  "fun [SO3_SCENE] I",                                                                                                                                                                                         SO3WorldGetFrictionModel                           },
  { "SO3WorldSetPlateformArchitecture",                      2,  "fun [SO3_SCENE I] I",                                                                                                                                                                                     SO3WorldSetPlateformArchitecture                   },
  { "SO3WorldGetPlateformArchitecture",                      1,  "fun [SO3_SCENE] I",                                                                                                                                                                                         SO3WorldGetPlateformArchitecture                   },
  { "SO3WorldSetSolverModel",                                2,  "fun [SO3_SCENE I] I",                                                                                                                                                                                     SO3WorldSetSolverModel                             },
  { "SO3WorldGetSolverModel",                                1,  "fun [SO3_SCENE] I",                                                                                                                                                                                         SO3WorldGetSolverModel                             },
  { "SO3WorldSetEnabled",                                    2,  "fun [SO3_SCENE I] I",                                                                                                                                                                                     SO3WorldSetEnabled                                 },
  { "SO3WorldGetEnabled",                                    1,  "fun [SO3_SCENE] I",                                                                                                                                                                                         SO3WorldGetEnabled                                 },
  { "SO3WorldShowLines",                                     2,  "fun [SO3_SCENE I] I",                                                                                                                                                                                     SO3WorldShowLines                                  },
  { "SO3WorldSetGravity",                                    2,  "fun [SO3_SCENE [F F F]] I",                                                                                                                                                                                 SO3WorldSetGravity                                 },
  { "SO3WorldGetGravity",                                    1,  "fun [SO3_SCENE] [F F F]",                                                                                                                                                                                   SO3WorldGetGravity                                 },
  { "SO3WorldReset",                                         1,  "fun [SO3_SCENE] I",                                                                                                               SO3WorldReset                                      },
  { "SO3WorldSetBodiesInitialState",                         1,  "fun [SO3_SCENE] I",                                                                                                               SO3WorldSetBodiesInitialState                      },
  { "SO3BodyCreateBox",                                      2,  "fun [SO3_OBJECT [F F F]] SO3_PHYSICBODY",                                                                                                   SO3BodyCreateBox                                   },
  { "SO3BodyCreateEllipsoid",                                2,  "fun [SO3_OBJECT [F F F]] SO3_PHYSICBODY",                                                                                                   SO3BodyCreateEllipsoid                             },
  { "SO3BodyCreateCapsule",                                  3,  "fun [SO3_OBJECT F F] SO3_PHYSICBODY",                                                                                                               SO3BodyCreateCapsule                               },
  { "SO3BodyCreateChamferCylinder",                          3,  "fun [SO3_OBJECT F F] SO3_PHYSICBODY",                                                                                                               SO3BodyCreateChamferCylinder                       },
  { "SO3BodyCreateCone",                                     3,  "fun [SO3_OBJECT F F] SO3_PHYSICBODY",                                                                                                               SO3BodyCreateCone                                  },
  { "SO3BodyCreateCylinder",                                 3,  "fun [SO3_OBJECT F F] SO3_PHYSICBODY",                                                                                                               SO3BodyCreateCylinder                              },
  { "SO3BodyCreatePyramid",                                  2,  "fun [SO3_OBJECT [F F F]] SO3_PHYSICBODY",                                                                                                   SO3BodyCreatePyramid                               },
  { "SO3BodyCreateBoxExt",                                   4,  "fun [SO3_OBJECT [F F F] [F F F] [F F F F]] SO3_PHYSICBODY",                                                                         SO3BodyCreateBoxExt                                },
  { "SO3BodyCreateEllipsoidExt",                             4,  "fun [SO3_OBJECT [F F F] [F F F] [F F F F]] SO3_PHYSICBODY",                                                                         SO3BodyCreateEllipsoidExt                          },
  { "SO3BodyCreateCapsuleExt",                               5,  "fun [SO3_OBJECT F F [F F F] [F F F F]] SO3_PHYSICBODY",                                                                                             SO3BodyCreateCapsuleExt                            },
  { "SO3BodyCreateChamferCylinderExt",                       5,  "fun [SO3_OBJECT F F [F F F] [F F F F]] SO3_PHYSICBODY",                                                                                             SO3BodyCreateChamferCylinderExt                    },
  { "SO3BodyCreateConeExt",                                  5,  "fun [SO3_OBJECT F F [F F F] [F F F F]] SO3_PHYSICBODY",                                                                                             SO3BodyCreateConeExt                               },
  { "SO3BodyCreateCylinderExt",                              5,  "fun [SO3_OBJECT F F [F F F] [F F F F]] SO3_PHYSICBODY",                                                                                             SO3BodyCreateCylinderExt                           },
  { "SO3BodyCreatePyramidExt",                               4,  "fun [SO3_OBJECT [F F F] [F F F] [F F F F]] SO3_PHYSICBODY",                                                                         SO3BodyCreatePyramidExt                            },
  { "SO3BodyCreateCollisionTree",                            2,  "fun [SO3_OBJECT I] SO3_PHYSICBODY",                                                                                                                               SO3BodyCreateCollisionTree                         },
  { "SO3BodyCreateShape",                                    2,  "fun [SO3_OBJECT F] SO3_PHYSICBODY",                                                                                                                               SO3BodyCreateShape                                 },
  { "SO3BodyCreateConcaveShape",                             2,  "fun [SO3_OBJECT F] SO3_PHYSICBODY",                                                                                                                               SO3BodyCreateConcaveShape                          },
  { "SO3BodyGetShapeDefinition",                             1,  "fun [SO3_PHYSICBODY] [I F [F F] [F F F] [F F F] [F F F F]]",                                                                                  SO3BodyGetShapeDefinition                          },
  { "SO3BodySetMass",                                        2,  "fun [SO3_PHYSICBODY F] I",                                                                                                                                  SO3BodySetMass                                     },
  { "SO3BodyCreateBasicJointUpVector",                       2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyCreateBasicJointUpVector                    },
  { "SO3BodyDestroyBasicJointUpVector",                      1,  "fun [SO3_PHYSICBODY] I",                                                                                                          SO3BodyDestroyBasicJointUpVector                   },
  { "SO3BodySetForce",                                       2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetForce                                    },
  { "SO3BodyAddForce",                                       2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyAddForce                                    },
  { "SO3BodyGetForce",                                       1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                            SO3BodyGetForce                                    },
  { "SO3BodyAddGlobalForce",                                 2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyAddGlobalForce                              },
  { "SO3BodyAddLocalForce",                                  2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyAddLocalForce                               },
  { "SO3BodyAddTorque",                                      2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyAddTorque                                   },
  { "SO3BodySetTorque",                                      2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetTorque                                   },
  { "SO3BodySetOmega",                                       2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetOmega                                    },
  { "SO3BodySetVelocity",                                    2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetVelocity                                 },
  { "SO3BodyAddImpulse",                                     3,  "fun [SO3_PHYSICBODY [F F F] [F F F]] I",                                                                                                          SO3BodyAddImpulse                                  },
  { "SO3BodyMoveTo",                                         3,  "fun [SO3_PHYSICBODY [F F F] F] I",                                                                                                              SO3BodyMoveTo                                      },
  { "SO3BodyRotateTo",                                       3,  "fun [SO3_PHYSICBODY [F F F F] F] I",                                                                                                          SO3BodyRotateTo                                    },
  { "SO3BodySetPositionOrientation",                         3,  "fun [SO3_PHYSICBODY [F F F] [F F F F]] I",                                                                                                SO3BodySetPositionOrientation                      },
  { "SO3BodySetAngularDamping",                              2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetAngularDamping                           },
  { "SO3BodySetCenterOfMass",                                2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetCenterOfMass                             },
  { "SO3BodySetMassMatrix",                                  3,  "fun [SO3_PHYSICBODY F [F F F]] I",                                                                                                              SO3BodySetMassMatrix                               },
  { "SO3BodyGetAngularDamping",                              1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                            SO3BodyGetAngularDamping                           },
  { "SO3BodyGetOmega",                                       1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                            SO3BodyGetOmega                                    },
  { "SO3BodyGetTorque",                                      1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                            SO3BodyGetTorque                                   },
  { "SO3BodySetConstantForce",                               2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetConstantForce                            },
  { "SO3BodyAddConstantForce",                               2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyAddConstantForce                            },
  { "SO3BodyGetConstantForce",                               1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                            SO3BodyGetConstantForce                            },
  { "SO3BodySetConstantTorque",                              2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodySetConstantTorque                           },
  { "SO3BodyAddConstantTorque",                              2,  "fun [SO3_PHYSICBODY [F F F]] I",                                                                                                                  SO3BodyAddConstantTorque                           },
  { "SO3BodyGetConstantTorque",                              1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                            SO3BodyGetConstantTorque                           },
  { "SO3BodySetLinearDamping",                               2,  "fun [SO3_PHYSICBODY F] I",                                                                                                                                        SO3BodySetLinearDamping                            },
  { "SO3BodySetAutoSleep",                                   2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetAutoSleep                                },
  { "SO3BodySetType",                                        2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetType                                     },
  { "SO3BodySetInitialState",                                1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                          SO3BodySetInitialState                             },
  { "SO3BodySetContiniousCollisionMode",                     2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetContiniousCollisionMode                  },
  { "SO3BodyCalculateOffset",                                1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                                  SO3BodyCalculateOffset                             },
  { "SO3BodyGetLinearDamping",                               1,  "fun [SO3_PHYSICBODY] F",                                                                                                                                                  SO3BodyGetLinearDamping                            },
  { "SO3BodyGetInvMass",                                     1,  "fun [SO3_PHYSICBODY] [F [F F F]]",                                                                                                                          SO3BodyGetInvMass                                  },
  { "SO3BodyGetMassMatrix",                                  1,  "fun [SO3_PHYSICBODY] [F [F F F]]",                                                                                                                          SO3BodyGetMassMatrix                               },
  { "SO3BodyGetAutoSleep",                                   1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                  SO3BodyGetAutoSleep                                },
  { "SO3BodyGetSleepingState",                               1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                  SO3BodyGetSleepingState                            },
  { "SO3BodyGetType",                                        1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                  SO3BodyGetType                                     },
  { "SO3BodyGetContiniousCollisionMode",                     1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                  SO3BodyGetContiniousCollisionMode                  },
  { "SO3BodyGetCenterOfMass",                                1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                                  SO3BodyGetCenterOfMass                             },
  { "SO3BodyGetVelocity",                                    1,  "fun [SO3_PHYSICBODY] [F F F]",                                                                                                                                  SO3BodyGetVelocity                                 },
  { "SO3BodyGetPositionOrientation",                         1,  "fun [SO3_PHYSICBODY] [[F F F] [F F F F]]",                                                                                                SO3BodyGetPositionOrientation                      },
  { "SO3BodySetFreeze",                                      2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetFreeze                                   },
  { "SO3BodyGetFreeze",                                      1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                          SO3BodyGetFreeze                                   },
  { "SO3BodySetSimulation",                                  2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetSimulation                               },
  { "SO3BodyGetSimulation",                                  1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                          SO3BodyGetSimulation                               },
  { "SO3BodySetGravityEnable",                               2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetGravityEnable                            },
  { "SO3BodyGetGravityEnable",                               1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                          SO3BodyGetGravityEnable                            },
  { "SO3BodyGetSceneNode",                                   1,  "fun [SO3_PHYSICBODY] SO3_OBJECT",                                                                                                                                   SO3BodyGetSceneNode                                },
  { "SO3BodySetIgnoreCollision",                             2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                          SO3BodySetIgnoreCollision                          },
  { "SO3BodyGetIgnoreCollision",                             1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                          SO3BodyGetIgnoreCollision                          },
  { "SO3BodySetFluid",                                       2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                        SO3BodySetFluid                                    },
  { "SO3BodyGetFluid",                                       1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                          SO3BodyGetFluid                                    },
  { "SO3BodySetFluidVolumeRatio",                            2,  "fun [SO3_PHYSICBODY F] I",                                                                                                                                        SO3BodySetFluidVolumeRatio                         },
  { "SO3BodyGetFluidVolumeRatio",                            1,  "fun [SO3_PHYSICBODY] F",                                                                                                                                    SO3BodyGetFluidVolumeRatio                         },
  { "SO3BodyDestroy",                                        1,  "fun [SO3_PHYSICBODY] I",                                                                                                                                                                    SO3BodyDestroy                                     },
  { "SO3BodyShowDebug",                                      2,  "fun [SO3_PHYSICBODY I] I",                                                                                                                                                                SO3BodyShowDebug                                   },
  { "SO3SceneNodeGetBody",                                   1,  "fun [SO3_OBJECT] SO3_PHYSICBODY",                                                                                                                                   SO3SceneNodeGetBody                                },
  { "SO3BodySetMaterial",                                    2,  "fun [SO3_PHYSICBODY SO3_PHYSICMATERIAL] I",                                                                                         SO3BodySetMaterial                                 },
  { "SO3BodyGetMaterial",                                    1,  "fun [SO3_PHYSICBODY] SO3_PHYSICMATERIAL",                                                                                                   SO3BodyGetMaterial                                 },
  { "SO3PhysicsMaterialCreate",                              2,  "fun [SO3_SCENE S] SO3_PHYSICMATERIAL",                                                                                                                                            SO3PhysicsMaterialCreate                           },
  { "SO3PhysicsMaterialDestroy",                             1,  "fun [SO3_PHYSICMATERIAL] I",                                                                                                                                                      SO3PhysicsMaterialDestroy                          },
  { "SO3PhysicsMaterialSetDefaultElasticity",                3,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL F] I",                                                                                           SO3PhysicsMaterialSetDefaultElasticity             },
  { "SO3PhysicsMaterialSetDefaultFriction",                  4,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL F F] I",                                                                               SO3PhysicsMaterialSetDefaultFriction               },
  { "SO3PhysicsMaterialSetDefaultSoftness",                  3,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL F] I",                                                                                           SO3PhysicsMaterialSetDefaultSoftness               },
  { "SO3PhysicsMaterialSetDefaultCollidable",                3,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL I] I",                                                                                           SO3PhysicsMaterialSetDefaultCollidable             },
  { "SO3PhysicsMaterialSetSurfaceThickness",                 3,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL F] I",                                                                                           SO3PhysicsMaterialSetSurfaceThickness              },
  { "SO3PhysicsMaterialSetContiniousCollisionMode",          3,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL I] I",                                                                                           SO3PhysicsMaterialSetContiniousCollisionMode       },
  { "SO3CbMaterialCollision",                                4,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL fun [SO3_SCENE u0 SO3_PHYSICBODY SO3_PHYSICBODY [F F F] [F F F] [F F F] F] u1 u0 ] I", SO3CbMaterialCollision                             },
  { "SO3CbMaterialOverlapStarted",                           4,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL fun [SO3_SCENE u0 SO3_PHYSICBODY SO3_PHYSICBODY] u1 u0 ] I",                               SO3CbMaterialOverlapStarted                        },
  { "SO3CbMaterialOverlapEnded",                             4,  "fun [SO3_PHYSICMATERIAL SO3_PHYSICMATERIAL fun [SO3_SCENE u0 SO3_PHYSICBODY SO3_PHYSICBODY] u1 u0 ] I",                               SO3CbMaterialOverlapEnded                          },
  { "SO3CbBodyLeaveWorld",                                   3,  "fun [SO3_PHYSICBODY fun [SO3_PHYSICBODY u0] u1 u0] SO3_PHYSICBODY",                                                               SO3CbBodyLeaveWorld                                },
  { "SO3PhysicsGetMaterial",                                 2,  "fun [SO3_SCENE S] SO3_PHYSICMATERIAL",                                                                                                                                                  SO3PhysicsGetMaterial                              },
  { "SO3PhysicsGetMaterialName",                             1,  "fun [SO3_PHYSICMATERIAL] S",                                                                                                                                                      SO3PhysicsGetMaterialName                          },
  { "SO3PhysicsRayCast",                                     4,  "fun [SO3_SCENE [F F F] [F F F] F] [SO3_PHYSICBODY F [F F F]]",                                                                    SO3PhysicsRayCast                                  },
  { "SO3PhysicsRayCastExt",                                  4,  "fun [SO3_SCENE [F F F] [F F F] F] [[SO3_PHYSICBODY F [F F F]] r1]",                                                               SO3PhysicsRayCastExt                               },
  { "SO3PhysicsContraintDestroy",                            1,  "fun [SO3_PHYSICCONTRAINT] I",                                                                                                     SO3PhysicsContraintDestroy                         },
  { "SO3PhysicsContraintSetCollisionState",                  2,  "fun [SO3_PHYSICCONTRAINT I] I",                                                                                                   SO3PhysicsContraintSetCollisionState               },
  { "SO3PhysicsContraintGetCollisionState",                  1,  "fun [SO3_PHYSICCONTRAINT] I",                                                                                                     SO3PhysicsContraintGetCollisionState               },
  { "SO3PhysicsContraintSetStiffness",                       2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetStiffness                    },
  { "SO3PhysicsContraintGetStiffness",                       1,  "fun [SO3_PHYSICCONTRAINT] F",                                                                                                     SO3PhysicsContraintGetStiffness                    },
  { "SO3PhysicsContraintCreateBallAndSocket",                5,  "fun [SO3_SCENE SO3_PHYSICBODY SO3_PHYSICBODY [F F F] I] SO3_PHYSICCONTRAINT]",                                                    SO3PhysicsContraintCreateBallAndSocket             },
  { "SO3PhysicsContraintSetBallAndSocketLimits",             4,  "fun [SO3_PHYSICCONTRAINT F F F] I",                                                                                               SO3PhysicsContraintSetBallAndSocketLimits          },
  { "SO3PhysicsContraintSetBallAndSocketControlled",         2,  "fun [SO3_PHYSICCONTRAINT I] I",                                                                                                   SO3PhysicsContraintSetBallAndSocketControlled      },
  { "SO3PhysicsContraintSetBallAndSocketAngularVelocity",    2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetBallAndSocketAngularVelocity },
  { "SO3PhysicsContraintSetBallAndSocketYawAngle",           2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetBallAndSocketYawAngle        },
  { "SO3PhysicsContraintSetBallAndSocketPitchAngle",         2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetBallAndSocketPitchAngle      },
  { "SO3PhysicsContraintSetBallAndSocketRollAngle",          2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetBallAndSocketRollAngle       },
  { "SO3PhysicsContraintGetBallAndSocketAngle",              1,  "fun [SO3_PHYSICCONTRAINT] [F F F]",                                                                                               SO3PhysicsContraintGetBallAndSocketAngle           },
  { "SO3PhysicsContraintGetBallAndSocketOmega",              1,  "fun [SO3_PHYSICCONTRAINT] [F F F]",                                                                                               SO3PhysicsContraintGetBallAndSocketOmega           },
  { "SO3PhysicsContraintGetBallAndSocketForce",              1,  "fun [SO3_PHYSICCONTRAINT] [F F F]",                                                                                               SO3PhysicsContraintGetBallAndSocketForce           },
  { "SO3PhysicsContraintCreateHinge",                        6,  "fun [SO3_SCENE SO3_PHYSICBODY SO3_PHYSICBODY [F F F] [F F F] I] SO3_PHYSICCONTRAINT]",                                            SO3PhysicsContraintCreateHinge                     },
  { "SO3PhysicsContraintSetHingeLimits",                     3,  "fun [SO3_PHYSICCONTRAINT F F] I",                                                                                                 SO3PhysicsContraintSetHingeLimits                  },
  { "SO3PhysicsContraintGetHingeAngle",                      1,  "fun [SO3_PHYSICCONTRAINT] F",                                                                                                     SO3PhysicsContraintGetHingeAngle                   },
  { "SO3PhysicsContraintGetHingeOmega",                      1,  "fun [SO3_PHYSICCONTRAINT] F",                                                                                                     SO3PhysicsContraintGetHingeOmega                   },
  { "SO3PhysicsContraintGetHingeForce",                      1,  "fun [SO3_PHYSICCONTRAINT] [F F F]",                                                                                               SO3PhysicsContraintGetHingeForce                   },
  { "SO3PhysicsContraintSetHingeMotorAngle",                 4,  "fun [SO3_PHYSICCONTRAINT F F F] I",                                                                                               SO3PhysicsContraintSetHingeMotorAngle              },
  { "SO3PhysicsContraintSetHingeMotorOmega",                 3,  "fun [SO3_PHYSICCONTRAINT F F] I",                                                                                                 SO3PhysicsContraintSetHingeMotorOmega              },
  { "SO3PhysicsContraintSetHingeTorque",                     2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetHingeTorque                  },
  { "SO3PhysicsContraintSetHingeBrake",                      2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetHingeBrake                   },
  { "SO3PhysicsContraintSetHingeMotorEnable",                2,  "fun [SO3_PHYSICCONTRAINT I] I",                                                                                                   SO3PhysicsContraintSetHingeMotorEnable             },
  { "SO3PhysicsContraintCreateSlider",                       7,  "fun [SO3_SCENE SO3_PHYSICBODY SO3_PHYSICBODY [F F F] [F F F] I I] SO3_PHYSICCONTRAINT]",                                          SO3PhysicsContraintCreateSlider                    },
  { "SO3PhysicsContraintSetSliderLimits",                    3,  "fun [SO3_PHYSICCONTRAINT F F] I",                                                                                                 SO3PhysicsContraintSetSliderLimits                 },
  { "SO3PhysicsContraintSetSliderSpring",                    3,  "fun [SO3_PHYSICCONTRAINT F F] I",                                                                                                 SO3PhysicsContraintSetSliderSpring                 },
  { "SO3PhysicsContraintSetSliderFriction",                  2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetSliderFriction               },
  { "SO3PhysicsContraintGetSliderVelocity",                  1,  "fun [SO3_PHYSICCONTRAINT] F",                                                                                                     SO3PhysicsContraintGetSliderVelocity               },
  { "SO3PhysicsContraintGetSliderForce",                     1,  "fun [SO3_PHYSICCONTRAINT] [F F F]",                                                                                               SO3PhysicsContraintGetSliderForce                  },
  { "SO3PhysicsContraintGetSliderPosition",                  1,  "fun [SO3_PHYSICCONTRAINT] F",                                                                                                     SO3PhysicsContraintGetSliderPosition               },
  { "SO3PhysicsContraintSetSliderMotorEnable",               2,  "fun [SO3_PHYSICCONTRAINT I] I",                                                                                                   SO3PhysicsContraintSetSliderMotorEnable            },
  { "SO3PhysicsContraintSetSliderMotorVelocity",             3,  "fun [SO3_PHYSICCONTRAINT F F] I",                                                                                                 SO3PhysicsContraintSetSliderMotorVelocity          },
  { "SO3PhysicsContraintCreateVehicle",                      2,  "fun [SO3_SCENE SO3_PHYSICBODY] SO3_PHYSICCONTRAINT",                                                                              SO3PhysicsContraintCreateVehicle                   },
  { "SO3PhysicsContraintAddVehicleTire",                     11, "fun [SO3_PHYSICCONTRAINT SO3_OBJECT F F F F F F F I I] I",                                                                        SO3PhysicsContraintAddVehicleTire                  },
  { "SO3PhysicsContraintGetVehicleSpeed",                    1,  "fun [SO3_PHYSICCONTRAINT] F",                                                                                                     SO3PhysicsContraintGetVehicleSpeed                 },
  { "SO3PhysicsContraintSetVehicleSteerAngle",               2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetVehicleSteerAngle            },
  { "SO3PhysicsContraintSetVehicleDrivingTorque",            2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetVehicleDrivingTorque         },
  { "SO3PhysicsContraintSetVehicleBrake",                    2,  "fun [SO3_PHYSICCONTRAINT F] I",                                                                                                   SO3PhysicsContraintSetVehicleBrake                 },
  { "SO3PhysicsContraintGetVehicleOnAir",                    1,  "fun [SO3_PHYSICCONTRAINT] I",                                                                                                     SO3PhysicsContraintGetVehicleOnAir                 },
  { "SO3PhysicsContraintGetVehicleTireAngularVelocity",      2,  "fun [SO3_PHYSICCONTRAINT SO3_OBJECT] F",                                                                                          SO3PhysicsContraintGetVehicleTireAngularVelocity   },
  { "SO3PhysicsContraintGetVehicleTireOnAir",                2,  "fun [SO3_PHYSICCONTRAINT SO3_OBJECT] I",                                                                                          SO3PhysicsContraintGetVehicleTireOnAir             },
  { "SO3WorldApplyImpulsePoint",                             4,  "fun [SO3_SCENE [F F F] F F] I",                                                                                                                                                                               SO3WorldApplyImpulsePoint                          }
};
 
 
int SCOLloadPhysics(mmachine m, cbmachine w)
{
  /* NB : Test à Faire : Creation Object PHYSICCB puis modifier SO3CbMaterialCollision avec "fun [SO3_SCENE SO3_PHYSICCB fun [S u0] u1 u0] I"
  */
  SO3_MATERIALPAIR_OVERLAP_STARTED_MSG = OBJgetUserEvent();
  OBJdefEvent(SO3_MATERIALPAIR_OVERLAP_STARTED_MSG, getMaterialOverlapStartedCallback);
  SO3_MATERIALPAIR_OVERLAP_ENDED_MSG = OBJgetUserEvent();
  OBJdefEvent(SO3_MATERIALPAIR_OVERLAP_ENDED_MSG, getMaterialOverlapEndedCallback);
  SO3_MATERIALPAIR_COLLISION_MSG = OBJgetUserEvent();
  OBJdefEvent(SO3_MATERIALPAIR_COLLISION_MSG, getMaterialContactCallback);
  //SO3_BODY_LEAVE_WORLD_MSG = OBJgetUserEvent();
  //OBJdefEvent(SO3_BODY_LEAVE_WORLD_MSG, getBodyLeaveWorldCallback);
  return PKhardpak2(m, "SO3Phys.pkg", sizeof(natSO3Phys) / sizeof(natSO3Phys[0]), natSO3Phys);
}
 
 
int SCOLfreePhysics()
{
  return 0;
}