SO3Engine/SCOLPack/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/



#include        "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 = (SNode*) MMfetch(m, MTOP(obj), 0);
        if(node==NULL)
        {
                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;
        }

  int p=0;
  int tmp_res;
  SBoneMap boneListCopy = skeleton->GetBones();
  SBoneMap::const_iterator iBones = boneListCopy.begin();
  while (iBones != boneListCopy.end());
  {
    int b = OBJfindTH(m, SO3OBJTYPE, (int)(iBones->second));
                if(b!=NIL)      
      b = MMfetch(m, b, OFFOBJMAG);

    if(MMpush(m, b))            
      return MERRMEM;
        
    INVERT(m, 0, 1);
                p++;
    iBones++;
  }

  MMpull(m);
        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\n");
#endif

        int obj = MMget(m, 0);
        if(obj==NIL)
        {
                MMset(m, 0, NIL);
                return 0;
        }

        SNode* node = (SNode*) MMfetch(m, MTOP(obj), 0);
        if(node==NULL)
        {
                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;
        }

        SBone* rootBone = skeleton->GetRootBone();
        if(rootBone==0)
  {
    MMset(m, 0, NIL);
    return 0;
  }

        int so3obj = OBJfindTH(m, SO3OBJTYPE, (int)(rootBone));
  if(so3obj!=NIL)       
    so3obj = MMfetch(m, so3obj, OFFOBJMAG);
        
  MMset(m, 0, so3obj);
        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 = (SNode*) MMfetch(m, MTOP(obj), 0);
        if(node==NULL)
        {
                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;
}


#define NBBONEPKG 3


char* BONEname[NBBONEPKG]= 
{
        "SO3BoneListFromMesh",
        "SO3GetRootBoneFromMesh",
  "SO3GetBoneLocalOrientation"
};


int (*BONEFunc[NBBONEPKG])(mmachine m)=
{
        SO3BoneListFromMesh,
        SO3GetRootBoneFromMesh,
  SO3GetBoneLocalOrientation
};


int BONEnarg[NBBONEPKG]= 
{
        1,                                                                                                                                                              //SO3BoneListFromMesh
        1,                                                                                                                                                              //SO3GetRootBoneFromMesh
  2                                         //SO3GetBoneLocalOrientation
};


char* BONEType[NBBONEPKG]=
{
        "fun [SO3_OBJECT] [SO3_OBJECT r1]",                             //SO3BoneListFromMesh
        "fun [SO3_OBJECT] SO3_OBJECT",                                    //SO3GetRootBoneFromMesh
  "fun [SO3_OBJECT [F F F F]] [F F F F]"    //SO3GetBoneLocalOrientation
};


int SCOLloadBone(mmachine m,cbmachine w)
{       
        return PKhardpak( m, "Bone", NBBONEPKG, BONEname, BONEFunc, BONEnarg, BONEType );
}


int SCOLfreeBone()
{
        return 0;
}

---