SCOLBones.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"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3SceneGraph/SO3Bone.h"
#include "SO3SceneGraph/SO3Scene.h"
 
int SO3BoneListFromMesh(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG,"SO3BoneListFromMesh\n");
#endif
 
        int obj = MMget(m, 0);
        if(obj==NIL)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
        if(node == 0)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
  if(node->GetNodeType()!=SNode::ENTITY_TYPE_ID)
        {
                MMset(m, 0, NIL);
                return 0;
        }
        
        SEntity* curEntity = static_cast<SEntity*> (node);
  SSkeleton* skeleton = curEntity->GetSkeleton();
  if(skeleton == 0)
        {
                MMset(m, 0, NIL);
                return 0;
        }
  MMpull(m);
 
  int p=0;
  SBoneMap boneListCopy = skeleton->GetBones();
  SBoneMap::const_iterator iBones = boneListCopy.begin();
  while (iBones != boneListCopy.end());
  {
    int b = OBJfindTH(m, SO3OBJTYPE, SCOL_PTR (iBones->second));
                if(b!=NIL)      
      b = MMfetch(m, b, OFFOBJMAG);
 
    if(MMpush(m, b))
      return MERRMEM;
 
                p++;
    iBones++;
  }
 
        if(MMpush(m, NIL))              
    return MERRMEM;
 
        for(int j=0; j<p; j++)
        {
                if(MMpush(m, 2*2)) 
      return MERRMEM;
 
                if(int k=MBdeftab(m)) 
      return k;
        }
        return 0;
}
 
 
int SO3GetRootBoneFromMesh(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3GetRootBoneFromMesh: DEPRECATED!\n");
#endif
 
        int obj = MMget(m, 0);
        if(obj==NIL)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
        if(node == 0)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
  if(node->GetNodeType()!=SNode::ENTITY_TYPE_ID)
  {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SEntity* curEntity = static_cast<SEntity*> (node);
  SSkeleton* skeleton = curEntity->GetSkeleton();
        if(!skeleton)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SBoneMap rootBonesList = skeleton->GetRootBones();
  if(rootBonesList.empty())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
        int so3obj = OBJfindTH(m, SO3OBJTYPE, SCOL_PTR(rootBonesList.begin()->second));
  if(so3obj!=NIL)       
    so3obj = MMfetch(m, so3obj, OFFOBJMAG);
        
  MMset(m, 0, so3obj);
        return 0;
}
 
 
int SO3GetRootBonesFromMesh(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3GetRootBonesFromMesh\n");
#endif
 
        int obj = MMget(m, 0);
        if(obj==NIL)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
        if(node == 0)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
  if(node->GetNodeType()!=SNode::ENTITY_TYPE_ID)
  {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SEntity* curEntity = static_cast<SEntity*> (node);
  SSkeleton* skeleton = curEntity->GetSkeleton();
        if(!skeleton)
        {
                MMset(m, 0, NIL);
                return 0;
        }
  MMpull(m);
 
  int p=0;
  SBoneMap rootBoneListCopy = skeleton->GetRootBones();
  SBoneMap::iterator iRootBones = rootBoneListCopy.begin();
  while (iRootBones != rootBoneListCopy.end())
  {
    int b = OBJfindTH(m, SO3OBJTYPE, SCOL_PTR(iRootBones->second));
                if(b!=NIL)      
      b = MMfetch(m, b, OFFOBJMAG);
 
    if(MMpush(m, b))            
      return MERRMEM;
        
                p++;
    iRootBones++;
  }
 
        if(MMpush(m, NIL))              
    return MERRMEM;
 
        for(int j=0; j<p; j++)
        {
                if(MMpush(m, 2*2)) 
      return MERRMEM;
 
                if(int k=MBdeftab(m)) 
      return k;
        }
        return 0;
}
 
 
int SO3GetBoneLocalOrientation(mmachine m)
{
#ifdef SO3_DEBUG
        MMechostr(MSKDEBUG, "SO3GetBoneLocalOrientation\n");
#endif
 
  int q = MMpull(m);
        int obj = MMget(m, 0);
        if((obj==NIL) || (q==NIL))
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
        if(node == 0)
        {
                MMset(m, 0, NIL);
                return 0;
        }
 
  if(node->GetNodeType()!=SNode::BONE_TYPE_ID)
  {
                MMset(m, 0, NIL);
                return 0;
        }
 
        SBone* curBone = static_cast<SBone*> (node);
        if(!curBone)
        {
                MMset(m, 0, NIL);
                return 0;
        }
  
  int x = MMfetch(m, MTOP(q), 0);
  int y = MMfetch(m, MTOP(q), 1);
  int z = MMfetch(m, MTOP(q), 2);
  int w = MMfetch(m, MTOP(q), 3);
 
        if((x==NIL) || (y==NIL) || (z==NIL) || (w==NIL))
  {
    MMset(m, 0, NIL);
    return 0;   
  }
 
  Ogre::Quaternion quat = Ogre::Quaternion(MTOF(w), MTOF(x), MTOF(y), MTOF(z));
  quat.normalise();
  Ogre::Quaternion lquat = curBone->ConvertWorldToLocalOrientation(quat);
  
        int tuple = MMmalloc(m, 4, TYPETAB);
        if(tuple==NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
        MMstore(m, tuple, 0, FTOM((lquat.x)));
        MMstore(m, tuple, 1, FTOM((lquat.y)));
        MMstore(m, tuple, 2, FTOM((lquat.z)));
        MMstore(m, tuple, 3, FTOM((lquat.w)));
        MMset(m, 0, PTOM(tuple));
 
        return 0;
}
 
 
NativeDefinition natSO3Bone[] = {
        { "SO3BoneListFromMesh",         1,   "fun [SO3_OBJECT] [SO3_OBJECT r1]",                        SO3BoneListFromMesh        },
        { "SO3GetRootBoneFromMesh",      1,   "fun [SO3_OBJECT] SO3_OBJECT",                                     SO3GetRootBoneFromMesh     },
  { "SO3GetRootBonesFromMesh",     1,   "fun [SO3_OBJECT] [SO3_OBJECT r1]",      SO3GetRootBonesFromMesh    },
  { "SO3GetBoneLocalOrientation",  2,   "fun [SO3_OBJECT [F F F F]] [F F F F]",  SO3GetBoneLocalOrientation }
};
 
 
int SCOLloadBone(mmachine m,cbmachine w)
{       
        return PKhardpak2(m, "SO3Bone.pkg", sizeof(natSO3Bone) / sizeof(natSO3Bone[0]), natSO3Bone);
}
 
 
int SCOLfreeBone()
{
        return 0;
}