SO3Engine/SCOLPack/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) 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 "../SO3Animation/SO3Anim.h"
#include "../SO3Material/SO3Material.h"
#include "../SO3SceneGraph/SO3Entity.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 = (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);
        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 = (SNode*) MMfetch(m, MTOP(obj), 0);
        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);
  
  if (flags == NIL)
    flags = -1;
  else
    flags = MTOI(flags);
  
  curEntity->SetVisibilityFlags(flags);

        MMset(m, 0, ITOM(0));
        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 = (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);

        MMset(m, 0, ITOM(curEntity->GetVisibilityFlags()));
        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 = (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;
        }
  
  unsigned int uidx = MTOI(idx);

        SEntity* curEntity = static_cast<SEntity*> (node);
  if(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 = (SNode*) MMfetch(m, MTOP(ent), 0);
  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);
  
  //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)
    {
      MMpush(m, 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 = (SNode*) MMfetch(m, MTOP(ent), 0);
        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);
  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.isNull())
                {
                        //get existing skeleton and set on mesh
                        entity->getOgreEntityPointer()->getMesh()->_notifySkeleton(sklptr);
                }
                else
                {
                        //load skeleton and set on mesh
                        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 = 0;
    try
    {
      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.
      SAnimMap animationsListCopy = newSkeleton->GetAnimations();
      SAnimMap::iterator iAnimation = animationsListCopy.begin();
            while(iAnimation != animationsListCopy.end())
            {
        SAnim* newAnimation = iAnimation->second;
        assert(newAnimation != 0);
        createAnim(m, newAnimation, entity);
        //restore the stak state
        MMpull(m);

        SAnimTrackList animationsTracksListCopy = newAnimation->GetAnimationsTracks();
        SAnimTrackList::iterator iAnimationTrack = animationsTracksListCopy.begin();
        while(iAnimationTrack != animationsTracksListCopy.end())
              {
          SAnimTrack* newAnimationTrack = (*iAnimationTrack);
          assert(newAnimationTrack != 0);
                createAnimTrack(m, newAnimationTrack, newAnimation);
          //restore the stak state
          MMpull(m);

          iAnimationTrack++;
        }
        iAnimation++;
      }
    }
    catch(Ogre::Exception &e)
    {
      MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
      MMpush(m, NIL);           
      return 0; 
    }

                // Pose le résultat sur la pile
    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 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 = (SMaterial*) MMfetch(m, MTOP(mat), 0);
  if (material==NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
        
  SNode* mNode = (SNode*) MMfetch(m, MTOP(ent), 0);
  if (mNode->GetNodeType() != SNode::ENTITY_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SEntity* entity = static_cast <SEntity*> (mNode);


  if((index == NIL)||((MTOI(index)) < 0))
    entity->getOgreEntityPointer()->setMaterialName(material->GetName(), material->GetGroupName());
  else
  {
    unsigned int uidx = MTOI(index);
    if(uidx<entity->GetNumSubEntities())
      entity->getOgreEntityPointer()->getSubEntity(uidx)->setMaterialName(material->GetName(), material->GetGroupName());
  }

  MMset(m, 0, ITOM(1));
  return 0;
}


#define NBENTITYPKG 7


char* ENTITYname[NBENTITYPKG]= 
{
        "SO3EntityNumOfSubEntities",
        "SO3EntityGetMaterialByIndex",
  "SO3EntityMaterialList",
  "SO3EntityAttachSkeleton",
  "SO3EntitySetMaterial",
  "SO3EntitySetVisibilityFlags",
  "SO3EntityGetVisibilityFlags"
};


int (*ENTITYFunc[NBENTITYPKG])(mmachine m)=
{
        SO3EntityNumOfSubEntities,
        SO3EntityGetMaterialByIndex,
  SO3EntityMaterialList,
  SO3EntityAttachSkeleton,
  SO3EntitySetMaterial,
  SO3EntitySetVisibilityFlags,
  SO3EntityGetVisibilityFlags
};


int ENTITYnarg[NBENTITYPKG]= 
{
        1,                                                                                                                                                              //SO3EntityNumOfSubEntities
        2,                                                                                                                                                  //SO3EntityGetMaterialByIndex
  1,                                        //SO3EntityMaterialList
  2,                                        //SO3EntityAttachSkeleton,
  3,                                        //SO3EntitySetMaterial
  2,                                        //SO3EntitySetVisibilityFlags
  1                                         //SO3EntityGetVisibilityFlags
};


char* ENTITYType[NBENTITYPKG]=
{
        "fun [SO3_OBJECT] I",                                                           //SO3EntityNumOfSubEntities
        "fun [SO3_OBJECT I] SO3_MATERIAL",                              //SO3EntityGetMaterialByIndex
  "fun [SO3_OBJECT] [SO3_MATERIAL r1]",                 //SO3EntityMaterialList
  "fun [SO3_OBJECT P] SO3_OBJECT",          //SO3EntityAttachSkeleton
  "fun [SO3_OBJECT SO3_MATERIAL I] I",      //SO3EntitySetMaterial
  "fun [SO3_OBJECT I] I",                   //SO3EntitySetVisibilityFlags
  "fun [SO3_OBJECT] I"                      //SO3EntityGetVisibilityFlags
};


int SCOLloadEntity(mmachine m,cbmachine w)
{       
        return PKhardpak(m, "Entity", NBENTITYPKG, ENTITYname, ENTITYFunc, ENTITYnarg, ENTITYType);
}


int SCOLfreeEntity()
{
        return 0;
}

---