SCOLAnim.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 <boost/format.hpp>
 
#include "SCOLPack/SO3SCOL.h"
 
// Animation includes
#include "SO3Animation/SO3Anim.h"
#include "SO3Animation/SO3AnimTrack.h"
#include "SO3Animation/SO3SequenceAnimationTrack.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3SceneGraph/SO3Bone.h"
 
 
int ANIMATION_END_EVENT;
 
int getAnimationCallbackEndEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getAnimationCallbackEndEvent\n");
#endif
 
  int k;
  int res = 0;
 
  if (!(k = OBJbeginreflex(m, SO3ANIM, SCOL_PTR id, SO3_ANIM_END)))
  {
    res = OBJcallreflex(m, 0);
  }
  return res;
}
 
 
int SO3AnimTrackGetObject(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackGetObject\n");
#endif
 
  int at = MMget(m, 0);
  if (at == NIL)
  {
    MMechostr(MSKDEBUG, "AnimTrack IS NIL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* animTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (animTrack == NULL)
  {
    MMechostr(MSKDEBUG, "AnimTrack IS NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (animTrack->GetType() != SAnimTrack::SO3_NODE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SNode* curNode = animTrack->GetParentAnimation()->GetParentNode();
    if (curNode == NULL)
    {
      MMechostr(MSKDEBUG, "curNode==NULL \n");
      MMset(m, 0, NIL);
      return 0;
    }
 
    int n = OBJfindTH(m, SO3OBJTYPE, SCOL_PTR (curNode));
    if (n != NIL)
      n = MMfetch(m, n, OFFOBJMAG);
 
    MMset(m, 0, n);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
  }
 
  return 0;
}
 
 
int SO3AnimTrackCreateKey(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackCreateKey\n");
#endif
 
  int sc = MTOP(MMpull(m));
  int q = MTOP(MMpull(m));
  int t = MTOP(MMpull(m));
  int keyFrame = MMpull(m);
  int at = MMget(m, 0);
  if ((at == NIL) || (keyFrame == NIL) || (t == NIL) || (q == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_NODE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 pos;
  pos.x = (MMfetch(m, t, 0) == NIL) ? 0.0f : MTOF(MMfetch(m, t, 0));
  pos.y = (MMfetch(m, t, 1) == NIL) ? 0.0f : MTOF(MMfetch(m, t, 1));
  pos.z = (MMfetch(m, t, 2) == NIL) ? 0.0f : MTOF(MMfetch(m, t, 2));
 
  Ogre::Vector3 scale;
  scale.x = (MMfetch(m, sc, 0) == NIL) ? 1.0f : MTOF(MMfetch(m, sc, 0));
  scale.y = (MMfetch(m, sc, 1) == NIL) ? 1.0f : MTOF(MMfetch(m, sc, 1));
  scale.z = (MMfetch(m, sc, 2) == NIL) ? 1.0f : MTOF(MMfetch(m, sc, 2));
 
  Ogre::Quaternion quat;
  quat.x = (MMfetch(m, q, 0) == NIL) ? 0.0f : MTOF(MMfetch(m, q, 0));
  quat.y = (MMfetch(m, q, 1) == NIL) ? 0.0f : MTOF(MMfetch(m, q, 1));
  quat.z = (MMfetch(m, q, 2) == NIL) ? 0.0f : MTOF(MMfetch(m, q, 2));
  quat.w = (MMfetch(m, q, 3) == NIL) ? 1.0f : MTOF(MMfetch(m, q, 3));
  quat.normalise();
 
  curAnimTrack->CreateKey(MTOF(keyFrame), pos, quat, scale);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimTrackSetKeyTransform(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackSetKeyTransform\n");
#endif
 
  int sc = MTOP(MMpull(m));
  int q = MTOP(MMpull(m));
  int t = MTOP(MMpull(m));
  int keyFrame = MMpull(m);
  int at = MMget(m, 0);
  if ((at == NIL) || (keyFrame == NIL) || (t == NIL) || (q == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_NODE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 pos;
  pos.x = (MMfetch(m, t, 0) == NIL) ? 0.0f : MTOF(MMfetch(m, t, 0));
  pos.y = (MMfetch(m, t, 1) == NIL) ? 0.0f : MTOF(MMfetch(m, t, 1));
  pos.z = (MMfetch(m, t, 2) == NIL) ? 0.0f : MTOF(MMfetch(m, t, 2));
 
  Ogre::Vector3 scale;
  scale.x = (MMfetch(m, sc, 0) == NIL) ? 1.0f : MTOF(MMfetch(m, sc, 0));
  scale.y = (MMfetch(m, sc, 1) == NIL) ? 1.0f : MTOF(MMfetch(m, sc, 1));
  scale.z = (MMfetch(m, sc, 2) == NIL) ? 1.0f : MTOF(MMfetch(m, sc, 2));
 
  Ogre::Quaternion quat;
  quat.x = (MMfetch(m, q, 0) == NIL) ? 0.0f : MTOF(MMfetch(m, q, 0));
  quat.y = (MMfetch(m, q, 1) == NIL) ? 0.0f : MTOF(MMfetch(m, q, 1));
  quat.z = (MMfetch(m, q, 2) == NIL) ? 0.0f : MTOF(MMfetch(m, q, 2));
  quat.w = (MMfetch(m, q, 3) == NIL) ? 1.0f : MTOF(MMfetch(m, q, 3));
  quat.normalise();
 
  curAnimTrack->SetKeyTransform(MTOI(keyFrame), pos, quat, scale);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimTrackGetKeyTransform(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackGetKeyTransform\n");
#endif
 
  int keyFrame = MMpull(m);
  int at = MMget(m, 0);
  if ((at == NIL) || (keyFrame == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_NODE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Ogre::Vector3 pos;
  Ogre::Quaternion quat;
  Ogre::Vector3 scale;
 
  curAnimTrack->GetKeyTransform(MTOI(keyFrame), pos, quat, scale);
 
  // Translation
  int trans = MMmalloc(m, 3, TYPETAB);
  if (trans == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, trans, 0, FTOM(pos.x));
  MMstore(m, trans, 1, FTOM(pos.y));
  MMstore(m, trans, 2, FTOM(pos.z));
  MMpush(m, PTOM(trans));
 
  // Orientation
  int torient = MMmalloc(m, 4, TYPETAB);
  if (torient == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, torient, 0, FTOM(quat.x));
  MMstore(m, torient, 1, FTOM(quat.y));
  MMstore(m, torient, 2, FTOM(quat.z));
  MMstore(m, torient, 3, FTOM(quat.w));
  MMpush(m, PTOM(torient));
 
  // scale
  int tscale = MMmalloc(m, 3, TYPETAB);
  if (tscale == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
  MMstore(m, tscale, 0, FTOM(scale.x));
  MMstore(m, tscale, 1, FTOM(scale.y));
  MMstore(m, tscale, 2, FTOM(scale.z));
  MMpush(m, PTOM(tscale));
 
  // 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));
  MMset(m, 0, PTOM(result));
  return 0;
}
 
 
int SO3AnimTrackGetNumKeys(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackGetNumKeys\n");
#endif
 
  int at = MMget(m, 0);
  if (at == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int nb = curAnimTrack->GetNumKeyFrames();
  MMset(m, 0, ITOM(nb));
  return 0;
}
 
 
int SO3AnimTrackGetKeyTime(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackGetKeyAtTime\n");
#endif
 
  int keyFrame = MMpull(m);
  int at = MMget(m, 0);
  if ((at == NIL) || (keyFrame == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float ptime = curAnimTrack->GetKeyPositionTime(MTOI(keyFrame));
 
  MMset(m, 0, FTOM(ptime));
  return 0;
}
 
 
int SO3AnimTrackRemoveKey(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackRemoveKey\n");
#endif
 
  int keyFrame = MMpull(m);
  int at = MMget(m, 0);
  if ((at == NIL) || (keyFrame == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((curAnimTrack->GetType() != SAnimTrack::SO3_NODE_TRACK) && (curAnimTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  curAnimTrack->RemoveKey(MTOI(keyFrame));
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimTrackOptimise(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackOptimise\n");
#endif
 
  int at = MMget(m, 0);
  if (at == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  curAnimTrack->SetOptimise();
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimTrackRemoveAllKeys(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackRemoveAllKeys\n");
#endif
 
  int at = MMget(m, 0);
  if (at == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((curAnimTrack->GetType() != SAnimTrack::SO3_NODE_TRACK) && (curAnimTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  curAnimTrack->RemoveAllKeyFrames();
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationGetName(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetName\n");
#endif
 
  int anim = MMpull(m);
  if (anim == NIL)
  {
    MMpush(m, NIL);
    return 0;
  };
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  // Scol name
  return Mpushstrbloc(m, (char*)animation->GetName().c_str());
}
 
 
int SO3AnimationSetLength(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetLength\n");
#endif
 
  int l = MMpull(m);
  int anim = MMget(m, 0);
  if ((anim == NIL) || (l == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetLength((Ogre::Real)MTOF(l));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationSetTimePosition(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetTimePosition\n");
#endif
 
  int t = MMpull(m);
  int anim = MMget(m, 0);
  if ((anim == NIL) || (t == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetTimePosition((Ogre::Real)MTOF(t));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationSetWeight(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetWeight\n");
#endif
 
  int w = MMpull(m);
  int anim = MMget(m, 0);
  if ((anim == NIL) || (w == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetInitialWeight((Ogre::Real)MTOF(w));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationSetInterpMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetInterpMode\n");
#endif
 
  int flag = MTOI(MMpull(m));
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetInterpolationMode(static_cast<SAnim::AnimInterpolationMode> (flag));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationSetRotInterpMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetRotInterpMode\n");
#endif
 
  int flag = MTOI(MMpull(m));
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetRotationInterpolationMode(static_cast<SAnim::AnimRotationInterpolationMode> (flag));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationGetInterpMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetInterpMode\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int flag = 0;
  flag = (int)(animation->GetInterpolationMode());
  MMset(m, 0, ITOM(flag));
  return 0;
}
 
 
int SO3AnimationGetType(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetType\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int flag = 0;
  flag = (int)(animation->GetType());
  MMset(m, 0, ITOM(flag));
  return 0;
}
 
 
int SO3AnimTrackDestroy(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackDestroy\n");
#endif
 
  int at = MMget(m, 0);
  if (at == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* animTrack = MMgetPointer<SAnimTrack*>(m, MTOP(at));
  if (animTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((animTrack->GetType() != SAnimTrack::SO3_NODE_TRACK) && (animTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SO3ANIMTRACK, at);
  MMset(m, 0, ITOM(1));
 
  return 0;
}
 
 
int SO3AnimationGetRotInterpMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetRotInterpMode\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int flag = 0;
  flag = (int)(animation->GetRotationInterpolationMode());
  MMset(m, 0, ITOM(flag));
  return 0;
}
 
 
int SO3AnimationSetEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetEnable\n");
#endif
 
  int bEnable = MTOI(MMpull(m));
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetEnable(!bEnable ? false : true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationSetPause(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetPause\n");
#endif
 
  int bPause = MTOI(MMpull(m));
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetPaused(!bPause ? false : true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationSetLoop(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetLoop\n");
#endif
  int bLoop = MTOI(MMpull(m));
  int anim = MMget(m, 0);
 
  if ((anim == NIL) || (bLoop == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetInitialLoop(!bLoop ? false : true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationOptimise(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationOptimise\n");
#endif
 
  int booleen = MTOI(MMpull(m));
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (booleen == 0)
    animation->SetOptimise(false);
  else
    animation->SetOptimise(true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationGetEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetEnable\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int booleen = 0;
  if (animation->GetEnable())
    booleen = 1;
 
  MMset(m, 0, ITOM(booleen));
  return 0;
}
 
 
int SO3AnimationGetPause(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetPause\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int booleen = 0;
  if (animation->GetPaused())
    booleen = 1;
 
  MMset(m, 0, ITOM(booleen));
  return 0;
}
 
 
int SO3AnimationGetLoop(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetLoop\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int state = 0;
  if (animation->GetInitialLoop())
    state = 1;
 
  MMset(m, 0, ITOM(state));
  return 0;
}
 
 
int SO3AnimationGetLength(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetLength\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float l = 0.0f;
  l = animation->GetLength();
  MMset(m, 0, FTOM(l));
  return 0;
}
 
 
int SO3AnimationGetTimePosition(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetTimePosition\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(animation->GetTimePosition()));
  return 0;
}
 
 
int SO3AnimationGetWeight(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetWeight\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(animation->GetInitialWeight()));
  return 0;
}
 
 
int SO3AnimationSetSpeed(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetSpeed\n");
#endif
 
  int fspeed = MMpull(m);
  int anim = MMget(m, 0);
  if ((anim == NIL) || (fspeed == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  animation->SetSpeed(MTOF(fspeed));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationGetSpeed(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetSpeed\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(animation->GetSpeed()));
  return 0;
}
 
 
int SO3AnimationHasEnded(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationHasEnded\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int booleen = 0;
  if (animation->HasEnded())
    booleen = 1;
 
  MMset(m, 0, ITOM(booleen));
  return 0;
}
 
 
int SO3AnimationNumOfAnimationTrack(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationNumOfAnimationTrack\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  val = animation->GetNumAnimationsTracks();
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3ObjectSkeletonNumOfAnimations(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectSkeletonNumOfAnimation\n");
#endif
 
  int skl = MMget(m, 0);
  if (skl == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(skl));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity == NULL)
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    if (entity->GetSkeleton() != 0)
    {
      int val = (int)entity->GetSkeleton()->GetNumAnimations();
      MMset(m, 0, ITOM(val));
    }
    else
      MMset(m, 0, NIL);
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectGetAnimations(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectGetAnimations\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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  int tmp_res;
  size_t numAnimations = node->GetNumAnimations();
 
  // Calculate the total animations of the node if it's an entity with a Skeleton attached
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    SSkeleton* entitySkeleton = entity->GetSkeleton();
    if (entitySkeleton != 0)
      numAnimations += entitySkeleton->GetNumAnimations();
  }
 
  if (numAnimations > 0)
  {
    const SAnimMap animationListCopy = node->GetAnimations();
    SAnimMap::const_iterator iAnimations = animationListCopy.begin();
    while (iAnimations != animationListCopy.end())
    {
      int a = OBJfindTH(m, SO3ANIM, SCOL_PTR (iAnimations->second));
 
      if (a != NIL)
        a = MMfetch(m, a, OFFOBJMAG);
 
      if (MMpush(m, a))
        return MERRMEM;
 
      INVERT(m, 0, 1);
      iAnimations++;
    }
 
    if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
    {
      SEntity* entity = static_cast<SEntity*> (node);
 
      // get all animations from list by entity and by type
      SSkeleton* entitySkeleton = entity->GetSkeleton();
      if (entitySkeleton != 0)
      {
        if (entitySkeleton->GetNumAnimations() > 0)
        {
          const SAnimMap animationListCopy = entitySkeleton->GetAnimations();
          SAnimMap::const_iterator iAnimations = animationListCopy.begin();
          while (iAnimations != animationListCopy.end())
          {
            int a = OBJfindTH(m, SO3ANIM, SCOL_PTR (iAnimations->second));
 
            if (a != NIL)
              a = MMfetch(m, a, OFFOBJMAG);
 
            if (MMpush(m, a))
              return MERRMEM;
 
            INVERT(m, 0, 1);
            iAnimations++;
          }
        }
      }
    }
 
    if (numAnimations == 0)
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    MMpull(m);
    if (MMpush(m, NIL))
      return MERRMEM;
 
    for (int j = 0; j<numAnimations; j++)
    {
      if (MMpush(m, 2 * 2))
        return MERRMEM;
 
      if (int k = MBdeftab(m))
        return k;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3AnimationListAnimTrack(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationListAnimTrack\n");
#endif
 
  int a = MMget(m, 0);
  if (a == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* anim = MMgetPointer<SAnim*>(m, MTOP(a));
  if (anim == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if ((anim->GetType() == SAnim::SO3_SCENENODE_ANIM) || (anim->GetType() == SAnim::SO3_SEQUENCE_ANIM))
  {
    int tmp_res;
    const SAnimTrackList animationTrackListCopy = anim->GetAnimationsTracks();
    SAnimTrackList::const_iterator iAnimTrackList = animationTrackListCopy.begin();
    while (iAnimTrackList != animationTrackListCopy.end())
    {
      int a = OBJfindTH(m, SO3ANIMTRACK, SCOL_PTR (*iAnimTrackList));
      if (a != NIL)
        a = MMfetch(m, a, OFFOBJMAG);
 
      if (MMpush(m, a))
        return MERRMEM;
 
      INVERT(m, 0, 1);
      iAnimTrackList++;
    }
    MMpull(m);
    if (MMpush(m, NIL))
      return MERRMEM;
 
    int numAnimations = anim->GetNumAnimationsTracks();
    for (int j = 0; j<numAnimations; j++)
    {
      if (MMpush(m, 2 * 2))
        return MERRMEM;
 
      if (int k = MBdeftab(m))
        return k;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectGetDisplaySkeleton(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectGetDisplaySkeleton\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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity->GetSkeleton() != 0)
    {
      // TODO re-factorisation
      int booleen = 0;
      if (entity->getOgreEntityPointer() && entity->getOgreEntityPointer()->getDisplaySkeleton())
        booleen = 1;
 
      MMset(m, 0, ITOM(booleen));
    }
    else
    {
      MMset(m, 0, NIL);
      return 0;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectHasSkeleton(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectHasSkeleton\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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    int booleen = 0;
    if (entity->GetSkeleton() != 0)
      booleen = 1;
 
    MMset(m, 0, ITOM(booleen));
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectIsHardwareSkinningEnabled(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectIsHardwareSkinningEnabled\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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity->GetSkeleton() != 0)
    {
      //TODO re-factorisation
      int booleen = 0;
      if (entity->getOgreEntityPointer() && entity->getOgreEntityPointer()->isHardwareAnimationEnabled())
        booleen = 1;
 
      MMset(m, 0, ITOM(booleen));
    }
    else
    {
      MMset(m, 0, NIL);
      return 0;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectSkeletonSetBindPose(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectSkeletonSetBindPose\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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity->GetSkeleton() != 0)
    {
      entity->GetSkeleton()->SetBindingPose();
      MMset(m, 0, ITOM(1));
    }
    else
    {
      MMset(m, 0, NIL);
      return 0;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectSkeletonGetBlendMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectSkeletonGetBlendMode\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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity->GetSkeleton() != 0)
    {
      SSkeleton::SkeletonAnimationMode flag = entity->GetSkeleton()->GetBlendMode();
      MMset(m, 0, ITOM(flag));
    }
    else
    {
      MMset(m, 0, NIL);
      return 0;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectSkeletonSetBlendMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectSkeletonSetBlendMode\n");
#endif
 
  int flag = MTOI(MMpull(m));
  int n = MMget(m, 0);
  if ((n == NIL) || (flag == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(n));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity->GetSkeleton() != 0)
    {
      entity->GetSkeleton()->SetBlendMode(static_cast<SSkeleton::SkeletonAnimationMode> (flag));
      MMset(m, 0, ITOM(1));
    }
    else
    {
      MMset(m, 0, NIL);
      return 0;
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3ObjectSetDisplaySkeleton(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ObjectSetDisplaySkeleton\n");
#endif
 
  int booleen = MTOI(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 == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() == SNode::ENTITY_TYPE_ID)
  {
    SEntity* entity = static_cast<SEntity*> (node);
    if (entity->GetSkeleton() != 0)
    {
      try
      {
        //TODO re-factorisation
        /*if(booleen == 0)entity->getOgreEntityPointer()->setDisplaySkeleton(true) ;
        else entity->getOgreEntityPointer()->setDisplaySkeleton(true) ;
        */
      }
      catch (Ogre::Exception &e)
      {
        MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
        MMset(m, 0, NIL);
        return 0;
      }
    }
    else
    {
      MMset(m, 0, NIL);
    }
  }
  else
    MMset(m, 0, NIL);
 
  return 0;
}
 
 
int SO3AnimationAddTime(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationAddTime\n");
#endif
 
  int time = MMpull(m);
  int anim = MMget(m, 0);
  if ((anim == NIL) || (time == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    animation->AddTime(MTOF(time));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationDestroy(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationDestroy\n");
#endif
 
  int a = MMget(m, 0);
  if (a == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* anim = MMgetPointer<SAnim*>(m, MTOP(a));
  if (anim == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SO3ANIM, a);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationGetAnimTrack(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetAnimTrack\n");
#endif
 
  int idx = MMpull(m);
  int anim = MMget(m, 0);
  if ((idx == NIL) || (anim == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SAnimTrack* mTrack = animation->GetAnimationTrack(MTOI(idx));
    if (mTrack == NULL)
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    int t = OBJfindTH(m, SO3ANIMTRACK, SCOL_PTR (mTrack));
    if (t != NIL)
      t = MMfetch(m, t, OFFOBJMAG);
 
    MMset(m, 0, t);
    return 0;
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimationCreateAnimTrack(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationCreateAnimTrack\n");
#endif
 
  // two last param are deprecated
  MMpull(m);
  MMpull(m);
  int anim = MMpull(m);
  if (anim == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  try
  {
    SAnimTrack* animationTrack = animation->CreateAnimationTrack(boost::str(boost::format("%1%") % animation->GetNumAnimationsTracks()));
    return createAnimTrack(m, animationTrack, animation);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMpush(m, NIL);
    return 0;
  }
}
 
 
int SO3AnimationSetSkipFrame(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationSetSkipFrame\n");
#endif
 
  int iState = MMpull(m);
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool bState = false;
  if ((iState != NIL) && (MTOI(iState) == 1))
    bState = true;
 
  animation->SetSkipFrame(bState);
 
  MMset(m, 0, ITOM(0));
  return 0;
}
 
 
int SO3AnimationGetSkipFrame(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimationGetSkipFrame\n");
#endif
 
  int anim = MMget(m, 0);
  if (anim == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool bState = animation->SkipFrame();
 
  MMset(m, 0, bState ? ITOM(1) : ITOM(0));
  return 0;
}
 
 
int SO3AnimTrackCreateSequenceKey(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackCreateSequenceKey\n");
#endif
 
  int idecal = MMpull(m);
  int ipos = MMpull(m);
  int ilength = MMpull(m);
  int anim = MMpull(m);
  int track = MMget(m, 0);
  if ((anim == NIL) || (track == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float fpos = 0.0f;
  if (ipos != NIL)
    fpos = MTOF(ipos);
 
  float fdecal = 0.0f;
  if (idecal != NIL)
    fdecal = MTOF(idecal);
 
  float flength = 0.0f;
  if (ilength != NIL)
    flength = MTOF(ilength);
 
  SAnim* animation = MMgetPointer<SAnim*>(m, MTOP(anim));
  if (animation == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(track));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    static_cast<SSequenceAnimationTrack*>(curAnimTrack)->AddKey(animation, flength, fpos, fdecal);
  }
  catch (Ogre::Exception)
  {
    MMechostr(MSKRUNTIME, "SO3AnimationSequenceAddAnim : Bad animation track type");
    MMset(m, 0, ITOM(0));
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimTrackGetSequenceKey(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackGetSequenceKey\n");
#endif
 
  int index = MMpull(m);
  int track = MMget(m, 0);
  if ((track == NIL) || (index == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(track));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  index = MTOI(index);
 
  SAnim* keyAnim = 0;
  float keyTime = 0.0f;
  float keyLength = 0.0f;
  float keyTrans = 0.0f;
  float keyDecal = 0.0f;
 
  try
  {
    SSequenceAnimationTrack* track = static_cast<SSequenceAnimationTrack*>(curAnimTrack);
    if (!track)
    {
      MMset(m, 0, NIL);
      return 0;
    }
    SSequenceAnimationKey* key = track->GetKeyFromIndex(index);
    if (!key)
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    keyAnim = key->GetAnim();
    keyTime = key->GetPosition();
    keyLength = key->GetLength();
    keyTrans = key->GetTransitionTime();
    keyDecal = key->GetDecalTime();
 
    int t = OBJfindTH(m, SO3ANIM, SCOL_PTR (keyAnim));
    if (t != NIL)
      t = MMfetch(m, t, OFFOBJMAG);
 
    // FINAL TUPPLE 
    int result = MMmalloc(m, 4, TYPETAB);
    if (result == NIL)
    {
      MMset(m, 0, NIL);
      return MERRMEM;
    }
    MMstore(m, result, 0, t);
    MMstore(m, result, 1, FTOM(keyTime));
    MMstore(m, result, 2, FTOM(keyLength));
    MMstore(m, result, 3, FTOM(keyTrans));
    MMstore(m, result, 4, FTOM(keyDecal));
    MMset(m, 0, PTOM(result));
  }
  catch (Ogre::Exception)
  {
    MMechostr(MSKRUNTIME, "SO3AnimationSequenceAddAnim : Bad animation track type");
    MMset(m, 0, NIL);
    return 0;
  }
 
  return 0;
}
 
 
int SO3AnimTrackSetSequenceKey(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackSetSequenceKey\n");
#endif
 
  int idecal = MMpull(m);
  int ipos = MMpull(m);
  int ilength = MMpull(m);
  int index = MMpull(m);
  int track = MMget(m, 0);
  if ((index == NIL) || (track == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  index = MTOI(index);
 
  float fpos = 0.0f;
  if (ipos != NIL)
    fpos = MTOF(ipos);
 
  float fdecal = 0.0f;
  if (idecal != NIL)
    fdecal = MTOF(idecal);
 
  float flength = 0.0f;
  if (ilength != NIL)
    flength = MTOF(ilength);
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(track));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SSequenceAnimationTrack* track = static_cast<SSequenceAnimationTrack*>(curAnimTrack);
    if (!track)
    {
      MMset(m, 0, NIL);
      return 0;
    }
    track->SetKey(index, flength, fpos, fdecal);
  }
  catch (Ogre::Exception)
  {
    MMechostr(MSKRUNTIME, "SO3AnimationSequenceAddAnim : Bad animation track type");
    MMset(m, 0, ITOM(0));
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3AnimTrackMoveSequenceKey(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3AnimTrackMoveSequenceKey\n");
#endif
 
  int nindex = MMpull(m);
  int index = MMpull(m);
  int track = MMget(m, 0);
  if ((index == NIL) || (nindex == NIL) || (track == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  index = MTOI(index);
  nindex = MTOI(nindex);
 
  SAnimTrack* curAnimTrack = MMgetPointer<SAnimTrack*>(m, MTOP(track));
  if (curAnimTrack == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (curAnimTrack->GetType() != SAnimTrack::SO3_SEQUENCE_TRACK)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SSequenceAnimationTrack* track = static_cast<SSequenceAnimationTrack*>(curAnimTrack);
    if (!track)
    {
      MMset(m, 0, NIL);
      return 0;
    }
    track->MoveKeyFromIndex(index, nindex);
  }
  catch (Ogre::Exception)
  {
    MMechostr(MSKRUNTIME, "SO3AnimationSequenceAddAnim : Bad animation track type");
    MMset(m, 0, ITOM(0));
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3CbAnimationEnded(mmachine m)
{
  int k = OBJaddreflex(m, SO3ANIM, SO3_ANIM_END);
  return k;
}
 
 
NativeDefinition natSO3Anim[] = {
  { "SO3AnimTrackGetObject",                   1,    "fun [SO3_ANIMTRACK] SO3_OBJECT",                                          SO3AnimTrackGetObject },
  { "SO3AnimTrackCreateKey",                   5,    "fun [SO3_ANIMTRACK F [F F F] [F F F F] [F F F]] I",           SO3AnimTrackCreateKey },
  { "SO3AnimTrackSetKeyTransform",             5,    "fun [SO3_ANIMTRACK I [F F F] [F F F F] [F F F]] I",           SO3AnimTrackSetKeyTransform },
  { "SO3AnimTrackGetKeyTransform",             2,    "fun [SO3_ANIMTRACK I] [[F F F] [F F F F] [F F F]]",           SO3AnimTrackGetKeyTransform },
  { "SO3AnimTrackGetNumKeys",                  1,    "fun [SO3_ANIMTRACK] I",                                                                             SO3AnimTrackGetNumKeys },
  { "SO3AnimTrackGetKeyTime",                  2,    "fun [SO3_ANIMTRACK I] F",                                                                   SO3AnimTrackGetKeyTime },
  { "SO3AnimTrackRemoveKey",                   2,    "fun [SO3_ANIMTRACK I] I",                                                                   SO3AnimTrackRemoveKey },
  { "SO3AnimTrackOptimise",                    1,    "fun [SO3_ANIMTRACK] I",                                                                             SO3AnimTrackOptimise },
  { "SO3AnimTrackRemoveAllKeys",               1,    "fun [SO3_ANIMTRACK] I",                                                                             SO3AnimTrackRemoveAllKeys },
  { "SO3AnimationGetName",                     1,    "fun [SO3_ANIM] S",                                                                                            SO3AnimationGetName },
  { "SO3AnimationSetLenght",                   2,    "fun [SO3_ANIM F] I",                                                                                        SO3AnimationSetLength },
  { "SO3AnimationSetLength",                   2,    "fun [SO3_ANIM F] I",                                                                                        SO3AnimationSetLength },
  { "SO3AnimationSetTimePosition",             2,    "fun [SO3_ANIM F] I",                                                                                        SO3AnimationSetTimePosition },
  { "SO3AnimationSetWeight",                   2,    "fun [SO3_ANIM F] I",                                                                                        SO3AnimationSetWeight },
  { "SO3AnimationSetInterpMode",               2,    "fun [SO3_ANIM I] I",                                                                                        SO3AnimationSetInterpMode },
  { "SO3AnimationSetRotInterpMode",            2,    "fun [SO3_ANIM I] I",                                                                                        SO3AnimationSetRotInterpMode },
  { "SO3AnimationGetInterpMode",               1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationGetInterpMode },
  { "SO3AnimationGetType",                     1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationGetType },
  { "SO3AnimTrackDestroy",                     1,    "fun [SO3_ANIMTRACK] I",                                                                             SO3AnimTrackDestroy },
  { "SO3AnimationGetRotInterpMode",            1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationGetRotInterpMode },
  { "SO3AnimationSetEnable",                   2,    "fun [SO3_ANIM I] I",                                                                                        SO3AnimationSetEnable },
  { "SO3AnimationSetPause",                    2,    "fun [SO3_ANIM I] I",                                                                                        SO3AnimationSetPause },
  { "SO3AnimationSetLoop",                     2,    "fun [SO3_ANIM I] I",                                                                                        SO3AnimationSetLoop },
  { "SO3AnimationOptimise",                    2,    "fun [SO3_ANIM I] I",                                                                                        SO3AnimationOptimise },
  { "SO3AnimationGetEnable",                   1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationGetEnable },
  { "SO3AnimationGetPause",                    1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationGetPause },
  { "SO3AnimationGetLoop",                     1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationGetLoop },
  { "SO3AnimationGetLenght",                   1,    "fun [SO3_ANIM] F",                                                                                            SO3AnimationGetLength },
  { "SO3AnimationGetLength",                   1,    "fun [SO3_ANIM] F",                                                                                            SO3AnimationGetLength },
  { "SO3AnimationGetTimePosition",             1,    "fun [SO3_ANIM] F",                                                                                            SO3AnimationGetTimePosition },
  { "SO3AnimationGetWeight",                   1,    "fun [SO3_ANIM] F",                                                                                            SO3AnimationGetWeight },
  { "SO3AnimationHasEnded",                    1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationHasEnded },
  { "SO3AnimationNumOfAnimationTrack",         1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationNumOfAnimationTrack },
  { "SO3ObjectSkeletonNumOfAnimations",        1,    "fun [SO3_OBJECT] I",                                                                                        SO3ObjectSkeletonNumOfAnimations },
  { "SO3ObjectGetVertexAnimations",            1,    "fun [SO3_OBJECT] [SO3_ANIM r1]",                                          SO3ObjectGetAnimations },
  { "SO3ObjectGetAnimations",                  1,    "fun [SO3_OBJECT] [SO3_ANIM r1]",                                          SO3ObjectGetAnimations },
  { "SO3AnimationListAnimTrack",               1,    "fun [SO3_ANIM] [SO3_ANIMTRACK r1]",                                 SO3AnimationListAnimTrack },
  { "SO3ObjectGetDisplaySkeleton",             1,    "fun [SO3_OBJECT] I",                                                                                        SO3ObjectGetDisplaySkeleton },
  { "SO3ObjectHasSkeleton",                    1,    "fun [SO3_OBJECT] I",                                                                                        SO3ObjectHasSkeleton },
  { "SO3ObjectIsHardwareSkinningEnabled",      1,    "fun [SO3_OBJECT] I",                                                                                        SO3ObjectIsHardwareSkinningEnabled },
  { "SO3ObjectSkeletonSetBindPose",            1,    "fun [SO3_OBJECT] I",                                                                                        SO3ObjectSkeletonSetBindPose },
  { "SO3ObjectSkeletonSetBlendMode",           2,    "fun [SO3_OBJECT I] I",                                                                              SO3ObjectSkeletonSetBlendMode },
  { "SO3ObjectSkeletonGetBlendMode",           1,    "fun [SO3_OBJECT] I",                                                                                        SO3ObjectSkeletonGetBlendMode },
  { "SO3ObjectSetDisplaySkeleton",             2,    "fun [SO3_OBJECT I] SO3_OBJECT",                                             SO3ObjectSetDisplaySkeleton },
  { "SO3AnimationAddTime",                     2,    "fun [SO3_ANIM F] I",                                                                                        SO3AnimationAddTime },
  { "SO3AnimationDestroy",                     1,    "fun [SO3_ANIM] I",                                                                                            SO3AnimationDestroy },
  { "SO3AnimationGetAnimTrack",                2,    "fun [SO3_ANIM I] SO3_ANIMTRACK",                                    SO3AnimationGetAnimTrack },
  { "SO3AnimationSetSpeed",                    2,    "fun [SO3_ANIM F] I",                                                                                  SO3AnimationSetSpeed },
  { "SO3AnimationGetSpeed",                    1,    "fun [SO3_ANIM] F",                                                                                            SO3AnimationGetSpeed },
  { "SO3CbAnimationEnded",                     3,    "fun [SO3_ANIM fun [SO3_ANIM u0] u1 u0] SO3_ANIM",       SO3CbAnimationEnded },
  { "SO3AnimationCreateAnimTrack",             3,    "fun [SO3_ANIM SO3_OBJECT I] SO3_ANIMTRACK",             SO3AnimationCreateAnimTrack },
  { "SO3AnimationSetSkipFrame",                2,    "fun [SO3_ANIM I] I",                                    SO3AnimationSetSkipFrame },
  { "SO3AnimationGetSkipFrame",                1,    "fun [SO3_ANIM] I",                                      SO3AnimationGetSkipFrame },
  { "SO3AnimTrackCreateSequenceKey",           5,    "fun [SO3_ANIMTRACK SO3_ANIM F F F] I",                  SO3AnimTrackCreateSequenceKey },
  { "SO3AnimTrackGetSequenceKey",              2,    "fun [SO3_ANIMTRACK I] [SO3_ANIM F F F F]",              SO3AnimTrackGetSequenceKey },
  { "SO3AnimTrackSetSequenceKey",              5,    "fun [SO3_ANIMTRACK I F F F] I",                         SO3AnimTrackSetSequenceKey },
  { "SO3AnimTrackMoveSequenceKey",             3,    "fun [SO3_ANIMTRACK I I] I",                             SO3AnimTrackMoveSequenceKey }
};
 
 
int SCOLloadAnim(mmachine m, cbmachine w)
{
  ANIMATION_END_EVENT = OBJgetUserEvent();
  OBJdefEvent(ANIMATION_END_EVENT, getAnimationCallbackEndEvent);
  return PKhardpak2(m, "SO3Anim.pkg", sizeof(natSO3Anim) / sizeof(natSO3Anim[0]), natSO3Anim);
}
 
 
int SCOLfreeAnim()
{
  return 0;
}