SCOLEntity.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 "SO3Utils/SO3Exception.h"
#include "SO3Animation/SO3Anim.h"
#include "SO3Material/SO3Material.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Bone.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Skeleton.h"
 
 
int SO3EntityNumOfSubEntities(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityNumOfSubEntities\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 == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, ITOM(0));
    return 0;
  }
 
  SEntity* curEntity = static_cast<SEntity*> (node);
  MMset(m, 0, ITOM(curEntity->GetNumSubEntities()));
  return 0;
}
 
int SO3EntitySetVisibilityFlags(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntitySetVisibilityFlags\n");
#endif
 
  int flags = MMpull(m);
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMechostr(MSKDEBUG, "Not an Entity type");
    MMset(m, 0, NIL);
    return 0;
  }
  SEntity* curEntity = static_cast<SEntity*> (node);
 
  // NIL == -1, and -1 = 0xFFFFFFFF for int, so it's ok even with NIL!
  curEntity->SetVisibilityFlags(MTOI(flags));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3EntityGetVisibilityFlags(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGetVisibilityFlags\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 == 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);
  MMset(m, 0, ITOM(curEntity->GetVisibilityFlags()));
  return 0;
}
 
int SO3EntitySetVisibilityFlagIndexEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntitySetVisibilityFlagIndexEnable\n");
#endif
 
  int enable = MMpull(m);
  int flagIndex = MMpull(m);
  int obj = MMget(m, 0);
  if ((obj == NIL) || (flagIndex == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMechostr(MSKDEBUG, "Not an Entity type");
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    SEntity* curEntity = static_cast<SEntity*> (node);
    curEntity->SetVisibilityFlagIndexEnable(MTOI(flagIndex), (MTOI(enable) == 1) ? true : false);
    MMset(m, 0, ITOM(1));
  }
  catch (const SException&)
  {
    MMset(m, 0, ITOM(NIL));
  }
  return 0;
}
 
int SO3EntityGetVisibilityFlagIndexEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGetVisibilityFlagIndexEnable\n");
#endif
 
  int flagIndex = MMpull(m);
  int obj = MMget(m, 0);
  if ((obj == NIL) || (flagIndex == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
  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);
 
  try
  {
    SEntity* curEntity = static_cast<SEntity*> (node);
    if (curEntity->GetVisibilityFlagIndexEnable(MTOI(flagIndex)))
      MMset(m, 0, ITOM(1));
    else
      MMset(m, 0, ITOM(0));
  }
  catch (const SException&)
  {
    MMset(m, 0, ITOM(NIL));
  }
  return 0;
}
 
 
int SO3EntityGenerateLOD(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGenerateLOD\n");
#endif
 
  int nb = MMpull(m);
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
  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);
 
  int nbLevels = 0;
  if (nb != NIL)
    nbLevels = abs(MTOI(nb));
 
  try
  {
    SEntity* curEntity = static_cast<SEntity*>(node);
    curEntity->GenerateLOD(nbLevels);
    MMset(m, 0, ITOM(1));
  }
  catch (const SException&)
  {
    MMset(m, 0, ITOM(NIL));
  }
  return 0;
}
 
 
int SO3EntityGetMaterialByIndex(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGetMaterialByIndex\n");
#endif
 
  int idx = MMpull(m);
  int obj = MMget(m, 0);
  if ((obj == NIL) || (idx == NIL) || ((MTOI(idx)) < 0))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  unsigned int uidx = MTOI(idx);
 
  SEntity* curEntity = static_cast<SEntity*> (node);
  if (!curEntity->getOgreEntityPointer() || uidx >= curEntity->GetNumSubEntities())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterial* tmpMat = curEntity->GetParentScene()->GetMaterial(curEntity->GetGroupName(), curEntity->getOgreEntityPointer()->getSubEntity(uidx)->getMaterial()->getName());
  if (tmpMat == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  //remove last param
  MMpull(m);
  return createOrRetrieveScolMaterialAndSendToVM(m, curEntity->GetParentScene(), tmpMat);
}
 
 
int SO3EntityMaterialList(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityMaterialList\n");
#endif
 
  int ent = MMget(m, 0);
  if (ent == NIL)
  {
    MMechostr(MSKDEBUG, "Entity is NULL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ent));
  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;
  }
 
  //TODO in SEntity
  // Getting Materials
  int nbMat = entity->GetNumSubEntities();
  int k;
  int tmp_res, n = 0;
  for (int i = 0; i < nbMat; i++)
  {
    SMaterial* material = node->GetParentScene()->GetMaterial(entity->GetGroupName(), entity->getOgreEntityPointer()->getSubEntity(i)->getMaterial()->getName());
    if (material == NULL)
    {
      MMset(m, 0, NIL);
      return 0;
    }
 
    createOrRetrieveScolMaterialAndSendToVM(m, node->GetParentScene(), material);
    INVERT(m, 0, 1);
    n++;
  }
 
  MMpull(m);
  if (MMpush(m, NIL))
    return MERRMEM;
 
  for (int j = 0; j < n; j++)
  {
    if (MMpush(m, 2 * 2))
      return MERRMEM;
 
    if (k = MBdeftab(m))
      return k;
  }
  return 0;
}
 
 
int SO3EntityAttachSkeleton(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityAttachSkeleton\n");
#endif
 
  int p = MMpull(m);
  int ent = MMpull(m);
 
  if ((p == NIL) || (ent == NIL))
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ent));
  if (node == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SEntity* entity = static_cast<SEntity*> (node);
  if (!entity || !entity->getOgreEntityPointer())
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SScene* scene = entity->GetParentScene();
  string pathStd = MMstartstr(m, MTOP(p));
 
  for (unsigned int i = 0; i < pathStd.length(); i++)
  {
    if (pathStd.substr(i, 1) == "\\")
      pathStd.replace(i, 1, "/");
  }
 
  try
  {
    Ogre::SkeletonPtr sklptr = (Ogre::SkeletonPtr)scene->O3SkeletonManager->getByName(pathStd, entity->GetGroupName());
    if (sklptr && !sklptr->getRootBones().empty())
    {
      //get existing skeleton and set on mesh
      if (entity->getOgreEntityPointer()->getMesh()->getSkeleton() != sklptr)
      {
        entity->getOgreEntityPointer()->getMesh()->setSkeletonName(pathStd);
        entity->getOgreEntityPointer()->getMesh()->_notifySkeleton(sklptr);
      }
 
      // reset mesh to apply new skeleton
      Ogre::Entity* ogreEntity = entity->getOgreEntityPointer();
      ogreEntity->_initialise(true);
      entity->Reload();
    }
    else if (!sklptr)
    {
      //load skeleton and set on mesh
      if (entity->getOgreEntityPointer()->getMesh()->getSkeletonName() != pathStd)
      {
        entity->getOgreEntityPointer()->getMesh()->setSkeletonName(pathStd);
 
        // reset mesh to apply new skeleton
        Ogre::Entity* ogreEntity = entity->getOgreEntityPointer();
        ogreEntity->_initialise(true);
        entity->Reload();
      }
    }
 
    /* TODO: Anims are handled differently now, not sure it's still useful...
    if(entity->getOgreEntityPointer()->hasVertexAnimation())
    {
      // Loading SCOL Animation
      // refresh all existing too
      for(int i=0;i<entity->getOgreEntityPointer()->getMesh()->getNumAnimations();i++)
      {
        Ogre::Animation* oanim = entity->getOgreEntityPointer()->getMesh()->getAnimation(i);
 
        // get all animations from list by entity and by type
        SAnim* anim = NULL;
 
        GetAnimByName(scene, &anim, node, entity->getOgreEntityPointer()->getName()+"."+oanim->getName());
        if(anim == NULL)
        {
          anim = new SVertexAnimation(oanim->getName(), entity, i);
 
          // Create AnimationState for each anim
          scene->listOfAnim.insert(SAnimMap::value_type(entity->getOgreEntityPointer()->getName()+"."+oanim->getName(), anim));
          int   a = createAnim(m,anim,(SNode*)entity);
          Ogre::Animation::VertexTrackIterator it = anim->getOgreAnimationPointer()->getVertexTrackIterator();
          while(it.hasMoreElements())
          {
            Ogre::VertexAnimationTrack* myTrack = static_cast <Ogre::VertexAnimationTrack*> (it.getNext());
            SAnimTrack* animationTrack = new SAnimTrack("TODO JEFF", anim, myTrack);
            anim->listOfAnimationTrack.insert(SAnimTrackMap::value_type("TODO JEFF", animationTrack));
            int at = createAnimTrack(m, animationTrack, anim);
          }
        }
        else
        {
          anim->setOgreAnimationPointer(oanim);
          //TODO update tracks
        }
      }
    }*/
 
    // Create skeleton
    string tmpSkeletonName = entity->GetName() + "." + pathStd;
    SSkeleton* newSkeleton = scene->CreateSkeleton(tmpSkeletonName, entity);
 
    // Create Scol Bones Object from skeleton SBone.
    SBoneMap bonesListCopy = newSkeleton->GetBones();
    SBoneMap::iterator iBone = bonesListCopy.begin();
    while (iBone != bonesListCopy.end())
    {
      SBone* newBone = iBone->second;
      assert(newBone != 0);
 
      createBone(m, (SNode*)newBone, scene, entity);
      //restore the stak state
      MMpull(m);
 
      iBone++;
    }
 
    // Create Scol Animations Object from skeleton SAnim.
    const SAnimMap animations = newSkeleton->GetAnimations();
    SAnimMap::const_iterator iAnimation = animations.begin();
    while (iAnimation != animations.end())
    {
      SAnim* newAnimation = iAnimation->second;
      assert(newAnimation != 0);
      createAnim(m, newAnimation, entity);
 
      const SAnimTrackList animationsTracksList = newAnimation->GetAnimationsTracks();
      SAnimTrackList::const_iterator iAnimationTrack = animationsTracksList.begin();
      while (iAnimationTrack != animationsTracksList.end())
      {
        SAnimTrack* newAnimationTrack = (*iAnimationTrack);
        assert(newAnimationTrack != 0);
        createAnimTrack(m, newAnimationTrack, newAnimation);
        //restore the stak state
        MMpull(m);
 
        iAnimationTrack++;
      }
      //restore the stak state
      MMpull(m);
      iAnimation++;
    }
 
    // push the result on stack
    MMpush(m, ent);
    return 0;
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMpush(m, NIL);
    return 0;
  }
}
 
 
int SO3EntityGetSkeleton(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGetSkeleton\n");
#endif
 
  int ent = MMpull(m);
 
  if (ent == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ent));
  if (node == NULL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SEntity* entity = static_cast<SEntity*> (node);
  if (!entity || !entity->getOgreEntityPointer() || !entity->GetSkeleton())
  {
    MMpush(m, NIL);
    return 0;
  }
 
  string pathStd = entity->GetSkeleton()->GetOgreSkeletonPointer()->getName();
 
  // push the result on stack
  Mpushstrbloc(m, (char*)pathStd.c_str());
  return 0;
}
 
int SO3EntitySetMaterial(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntitySetMaterial\n");
#endif
 
  int index = MMpull(m);
  int mat = MMpull(m);
  int ent = MMget(m, 0);
  if ((ent == NIL) || (mat == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SMaterial* material = MMgetPointer<SMaterial*>(m, MTOP(mat));
  if (material == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* mNode = MMgetPointer<SNode*>(m, MTOP(ent));
  if (mNode->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SEntity* entity = static_cast <SEntity*> (mNode);
  if (!entity)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (entity->SetMaterial(material, MTOI(index)))
    MMset(m, 0, ITOM(1));
  else
    MMset(m, 0, NIL);
  return 0;
}
 
int SO3EntityGetResourceGroup(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGetResourceGroup\n");
#endif
 
  int ent = MMget(m, 0);
  if (ent == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* mNode = MMgetPointer<SNode*>(m, MTOP(ent));
  if (mNode->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SEntity* entity = static_cast <SEntity*> (mNode);
  if (!entity || !entity->getOgreEntityPointer())
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  std::string group = entity->GetGroupName();
  group = group.substr(entity->GetParentScene()->GetName().length());
  Mpushstrbloc(m, (char*)group.c_str());
  return 0;
}
 
 
 
int SO3EntitySetMinPixelSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntitySetMinPixelSize\n");
#endif
 
  int imsize = MMpull(m);
  int obj = MMget(m, 0);
  if (obj == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(obj));
  if (node == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMechostr(MSKDEBUG, "Not an Entity type");
    MMset(m, 0, NIL);
    return 0;
  }
  SEntity* curEntity = static_cast<SEntity*> (node);
 
  float msize = 0.0f;
  if (imsize != NIL)
    msize = MTOF(imsize);
 
  curEntity->SetMinPixelSize(msize);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3EntityGetMinPixelSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3EntityGetMinPixelSize\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 == 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);
  MMset(m, 0, FTOM(curEntity->GetMinPixelSize()));
  return 0;
}
 
NativeDefinition natSO3Entity[] = {
  { "SO3EntityNumOfSubEntities",             1,  "fun [SO3_OBJECT] I",                                                     SO3EntityNumOfSubEntities             },
  { "SO3EntityGetMaterialByIndex",           2,  "fun [SO3_OBJECT I] SO3_MATERIAL",              SO3EntityGetMaterialByIndex           },
  { "SO3EntityMaterialList",                 1,  "fun [SO3_OBJECT] [SO3_MATERIAL r1]", SO3EntityMaterialList                 },
  { "SO3EntityAttachSkeleton",               2,  "fun [SO3_OBJECT P] SO3_OBJECT",      SO3EntityAttachSkeleton               },
  { "SO3EntityGetSkeleton",                  1,  "fun [SO3_OBJECT] P",                 SO3EntityGetSkeleton                  },
  { "SO3EntitySetMaterial",                  3,  "fun [SO3_OBJECT SO3_MATERIAL I] I",  SO3EntitySetMaterial                  },
  { "SO3EntityGetResourceGroup",             1,  "fun [SO3_OBJECT] S",                 SO3EntityGetResourceGroup             },
  { "SO3EntitySetVisibilityFlags",           2,  "fun [SO3_OBJECT I] I",               SO3EntitySetVisibilityFlags           },
  { "SO3EntityGetVisibilityFlags",           1,  "fun [SO3_OBJECT] I",                 SO3EntityGetVisibilityFlags           },
  { "SO3EntitySetVisibilityFlagIndexEnable", 3,  "fun [SO3_OBJECT I I] I",             SO3EntitySetVisibilityFlagIndexEnable },
  { "SO3EntityGetVisibilityFlagIndexEnable", 2,  "fun [SO3_OBJECT I] I",               SO3EntityGetVisibilityFlagIndexEnable },
  { "SO3EntityGenerateLOD",                  2,  "fun [SO3_OBJECT I] I",               SO3EntityGenerateLOD                  },
  { "SO3EntitySetMinPixelSize",              2,  "fun [SO3_OBJECT F] I",               SO3EntitySetMinPixelSize              },
  { "SO3EntityGetMinPixelSize",              1,  "fun [SO3_OBJECT] F",                 SO3EntityGetMinPixelSize              }
};
 
 
int SCOLloadEntity(mmachine m, cbmachine w)
{
  return PKhardpak2(m, "SO3Entity.pkg", sizeof(natSO3Entity) / sizeof(natSO3Entity[0]), natSO3Entity);
}
 
 
int SCOLfreeEntity()
{
  return 0;
}