SO3Entity.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 "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3Animation/SO3VertexAnimation.h"
#include "SO3Animation/SO3PoseAnimation.h"
#include "SO3Material/SO3Material.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Utils/SO3BaseMeshsTools.h"
 
#include "OgreMeshLodGenerator.h"
#include "OgrePixelCountLodStrategy.h"
#include "OgreLodData.h"
#include "OgreLodConfig.h"
#include "OgreLodCollapser.h"
 
  // Utils includes
#include "SO3Utils/SO3Exception.h"
 
extern int OBJECT_LOADED_EVENT;
 
namespace SO3
{
  SEntity::SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const std::string& meshName, bool loadInBackground) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = groupName;
    mReleaseResource = false;
    mResourceName = meshName;
    O3Entity = 0;
    mLoading = loadInBackground;
    mNumLodLevel = 0;
 
    bool lastLogstate = SRoot::getSingletonPtr()->GetLogEnable();
    SRoot::getSingletonPtr()->SetLogEnable(false);
 
    //group name or not Ogre get the previous loaded ressource if exist !! the same in load
    mMesh = Ogre::MeshManager::getSingleton().getByName(meshName, mGroupName);
 
    if (!mMesh)
    {
      if (loadInBackground)
      {
        try
        {
          mMesh = Ogre::MeshManager::getSingletonPtr()->create(meshName, mGroupName);
        }
        catch (Ogre::Exception &e)
        {
          SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
 
          // Catching .skeleton error. Forwarding other errors.
          if (e.getFullDescription().find(".skeleton") == std::string::npos)
          {
            Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
            throw e;
          }
        }
      }
      else
      {
        try
        {
          mMesh = Ogre::MeshManager::getSingletonPtr()->load(meshName, mGroupName);
        }
        catch (Ogre::Exception &e)
        {
          SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
 
          // Catching .skeleton error. Forwarding other errors.
          if (e.getFullDescription().find(".skeleton") == std::string::npos)
          {
            Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
            throw e;
          }
        }
      }
 
      SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
    }
 
    if (mMesh->isLoaded() && !loadInBackground)
    {
      //we don't use stencil shadows anymore
      mMesh->setAutoBuildEdgeLists(false);
      if (mMesh->hasSkeleton())
      {
        if (!currentScene->O3SkeletonManager->getByName(mMesh->getSkeletonName(), mMesh->getGroup()))
          mMesh->setSkeletonName("");
      }
 
      Ogre::PoseList plist = mMesh->getPoseList();
 
      // Check if there's an animation per pose, and create it in the mesh if not exists. NB that those are created in the mesh BEFORE creating the entity!
      if (plist.size() > 0)
      {
        for (unsigned int p = 0; p < plist.size(); p++)
        {
          Ogre::Pose* pose = plist[p];
          std::string animationName = pose->getName();
 
          // create the animation on the mesh if it doesn't already exist
          Ogre::Animation* ogreAnimation = 0;
          if (mMesh->hasAnimation(animationName) == false)
          {
            // Log a message for SO3Engine user.
            Ogre::LogManager::getSingleton().logMessage("No animation was found for mesh pose \"" + animationName + "\", SO3Engine will generate automatically an animation for it, but it'll be cleaner to create this animation in your modeler!");
 
            ogreAnimation = mMesh->createAnimation(animationName, 0);
 
            // SO3PoseAnimation will be created later in the CommonConstructorsSequence...
            // Store pose index as there's not simple way to retrieve this with ogre.
            poseHandleList.insert(PoseHandleList::value_type(animationName, p));
          }
          else
          {
            ogreAnimation = mMesh->getAnimation(animationName);
          }
 
          Ogre::ushort targetSubMesh = pose->getTarget();
          if (!ogreAnimation->hasVertexTrack(targetSubMesh))
          {
            Ogre::VertexAnimationTrack* vt = ogreAnimation->createVertexTrack(targetSubMesh, Ogre::VAT_POSE);
            vt->createVertexPoseKeyFrame(0)->addPoseReference(p, 0.0f);
          }
        }
      }
 
      //initialize LOD
      if (mMesh->getLodStrategy() != Ogre::ScreenRatioPixelCountLodStrategy::getSingletonPtr())
        mMesh->setLodStrategy(Ogre::ScreenRatioPixelCountLodStrategy::getSingletonPtr());
 
      O3Entity = currentScene->GetOgreScenePointer()->createEntity(GetName(), mResourceName, mGroupName);
 
      CommonConstructorsSequence();
    }
  }
 
  void SEntity::LoadAsync()
  {
    bool lastLogstate = SRoot::getSingletonPtr()->GetLogEnable();
    if (mMesh->isLoading())
    {
      mMesh->addListener(this);
    }
    else if (!mMesh->isLoaded())
    {
      SRoot::getSingletonPtr()->SetLogEnable(false);
      try
      {
        mMesh->addListener(this);
        Ogre::ResourceBackgroundQueue::getSingleton().load(mMesh);
      }
      catch (Ogre::Exception &e)
      {
        SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
 
        // Catching .skeleton error. Forwarding other errors.
        if (e.getFullDescription().find(".skeleton") == std::string::npos)
        {
          Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
          throw e;
        }
      }
      SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
    }
 
    if (mMesh->isLoaded())
      FinishAsync();
  }
 
  void SEntity::FinishAsync()
  {
    if (!mLoading)
      return;
 
    //we don't use stencil shadows anymore
    mMesh->setAutoBuildEdgeLists(false);
 
    if (mMesh->hasSkeleton())
    {
      if (!currentScene->O3SkeletonManager->getByName(mMesh->getSkeletonName(), mMesh->getGroup()))
        mMesh->setSkeletonName("");
    }
 
    /*if(mMesh->isLodManual())
    {
      Ogre::MeshManager::getSingleton().unload(mMesh->getHandle());
      OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "Cannot load a mesh with manual LOD!", "SEntity::SEntity");
    }*/
 
    //remove skeleton path (will be added after)
    //mMesh->setSkeletonName("");
 
    // Check if there's an animation per pose, and create it in the mesh if not exists. NB that those are created in the mesh BEFORE creating the entity!
    Ogre::PoseList poseList = mMesh->getPoseList();
    if (poseList.size() > 0)
    {
      for (unsigned int p = 0; p < poseList.size(); p++)
      {
        Ogre::Pose* pose = poseList[p];
        std::string animationName = pose->getName();
 
        // create the animation on the mesh if it doesn't already exist
        Ogre::Animation* ogreAnimation = 0;
        if (mMesh->hasAnimation(animationName) == false)
        {
          // Log a message for SO3Engine user.
          Ogre::LogManager::getSingleton().logMessage("No animation was found for mesh pose \"" + animationName + "\", SO3Engine will generate automatically an animation for it, but it'll be cleaner to create this animation in your modeler!");
 
          ogreAnimation = mMesh->createAnimation(animationName, 0);
 
          // SO3PoseAnimation will be created later in the CommonConstructorsSequence...
          // Store pose index as there's not simple way to retrieve this with ogre.
          poseHandleList.insert(PoseHandleList::value_type(animationName, p));
        }
        else
        {
          ogreAnimation = mMesh->getAnimation(animationName);
        }
 
        Ogre::ushort targetSubMesh = pose->getTarget();
        if (!ogreAnimation->hasVertexTrack(targetSubMesh))
        {
          Ogre::VertexAnimationTrack* vt = ogreAnimation->createVertexTrack(targetSubMesh, Ogre::VAT_POSE);
          vt->createVertexPoseKeyFrame(0)->addPoseReference(p, 0.0f);
        }
      }
    }
 
    O3Entity = currentScene->GetOgreScenePointer()->createEntity(GetName(), mResourceName, mGroupName);
    CommonConstructorsSequence();
 
    if (mNumLodLevel > 0)
      GenerateLOD(mNumLodLevel);
 
    mLoading = false;
 
    OBJpostEvent(OBJECT_LOADED_EVENT, SCOL_PTR this, 0);
  }
 
  void SEntity::loadingComplete(Ogre::Resource* res)
  {
    FinishAsync();
  }
 
 
  SEntity::SEntity(SScene* parent, const std::string& entityName, const std::string& groupName, Ogre::MeshPtr meshPointer) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = groupName;
    mReleaseResource = false;
    mResourceName = entityName;
    mLoading = false;
    mNumLodLevel = 0;
 
    SRoot* tmpRoot = SRoot::getSingletonPtr();
    assert(tmpRoot != 0);
 
    bool lastLogstate = tmpRoot->GetLogEnable();
    tmpRoot->SetLogEnable(false);
 
    //group name or not Ogre get the previous loaded ressource if exist !! the same in load
    mMesh = meshPointer;
    if (!mMesh)
    {
      try
      {
        mMesh = meshPointer;
      }
      catch (Ogre::Exception &e)
      {
        tmpRoot->SetLogEnable(lastLogstate);
 
        // Catching .skeleton error. Forwarding other errors.
        if (e.getFullDescription().find(".skeleton") == std::string::npos)
        {
          Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
          throw e;
        }
      }
 
      tmpRoot->SetLogEnable(lastLogstate);
 
      if (mMesh->hasSkeleton())
      {
        if (!currentScene->O3SkeletonManager->getByName(mMesh->getSkeletonName(), mMesh->getGroup()))
          mMesh->setSkeletonName("");
      }
    }
 
    //remove skeleton path (will be added after)
    //mMesh->setSkeletonName("");
 
    // Check if there's an animation per pose, and create it in the mesh if not exists. NB that those are created in the mesh BEFORE creating the entity!
    Ogre::PoseList poseList = mMesh->getPoseList();
    if (poseList.size() > 0)
    {
      for (unsigned int p = 0; p < poseList.size(); p++)
      {
        Ogre::Pose* pose = poseList[p];
        std::string animationName = pose->getName();
 
        // create the animation on the mesh if it doesn't already exist
        Ogre::Animation* ogreAnimation = 0;
        if (mMesh->hasAnimation(animationName) == false)
        {
          // Log a message for SO3Engine user.
          Ogre::LogManager::getSingleton().logMessage("No animation was found for mesh pose \"" + animationName + "\", SO3Engine will generate automatically an animation for it, but it'll be cleaner to create this animation in your modeler!");
 
          ogreAnimation = mMesh->createAnimation(animationName, 0);
 
          // SO3PoseAnimation will be created later in the CommonConstructorsSequence...
          // Store pose index as there's not simple way to retrieve this with ogre.
          poseHandleList.insert(PoseHandleList::value_type(animationName, p));
        }
        else
        {
          ogreAnimation = mMesh->getAnimation(animationName);
        }
 
        Ogre::ushort targetSubMesh = pose->getTarget();
        if (!ogreAnimation->hasVertexTrack(targetSubMesh))
        {
          Ogre::VertexAnimationTrack* vt = ogreAnimation->createVertexTrack(targetSubMesh, Ogre::VAT_POSE);
          vt->createVertexPoseKeyFrame(0)->addPoseReference(p, 0.0f);
        }
      }
    }
 
    O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, meshPointer);
    CommonConstructorsSequence();
  }
 
  SEntity::SEntity(SScene* parent, const std::string& entityName, const EntityPrefabType& prefabType) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = Ogre::RGN_DEFAULT;
    mReleaseResource = false;
    mResourceName = "";
    mMesh.reset();
    mLoading = false;
    mNumLodLevel = 0;
 
    switch (prefabType)
    {
    case SO3_PREFAB_PLANE:
      O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, Ogre::SceneManager::PT_PLANE);
      break;
    case SO3_PREFAB_CUBE:
      O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, Ogre::SceneManager::PT_CUBE);
      break;
    case SO3_PREFAB_SPHERE:
      O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, Ogre::SceneManager::PT_SPHERE);
      break;
    default:
      OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Unknow prefab type!", "SEntity::SEntity");
    }
    CommonConstructorsSequence();
  }
 
  //Plane object
  SEntity::SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const SPointFloat& sizev, const SPointInt& seg, const SPointFloat& uv) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = groupName;
    mReleaseResource = true;
    mResourceName = groupName + entityName + ".PlaneRes";
    mLoading = false;
    mNumLodLevel = 0;
 
    Ogre::Plane plane(Ogre::Vector3::UNIT_Y, 0);
    mMesh = Ogre::MeshManager::getSingleton().createPlane(mResourceName, mGroupName, plane, sizev.x, sizev.y, seg.x, seg.y, true, 1, uv.x, uv.y, Ogre::Vector3::UNIT_Z);
    O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, mResourceName, groupName);
    CommonConstructorsSequence();
  }
 
  //Sphere object
  SEntity::SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const float& radius, const int& rings, const int& segments) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = groupName;
    mReleaseResource = true;
    mResourceName = groupName + entityName + ".SphereRes";
    mLoading = false;
    mNumLodLevel = 0;
 
    mMesh = SBaseMeshsTools::CreateSphere(mResourceName, radius, rings, segments, true, true, mGroupName);
    O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, mResourceName, groupName);
    CommonConstructorsSequence();
  }
 
  //Cone object
  SEntity::SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const float& radius, const float& height, const int& segments) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = groupName;
    mReleaseResource = true;
    mResourceName = groupName + entityName + ".SphereRes";
    mLoading = false;
    mNumLodLevel = 0;
 
    mMesh = SBaseMeshsTools::CreateCone(mResourceName, radius, height, segments, mGroupName);
    O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, mResourceName, groupName);
    CommonConstructorsSequence();
  }
 
  //Octahedron object
  SEntity::SEntity(SScene* parent, const std::string& groupName, const std::string& entityName, const float& base, const float& bottom, const float& dist) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
  {
    entitySKL = 0;
    mGroupName = groupName;
    mReleaseResource = true;
    mResourceName = groupName + entityName + ".SphereRes";
    mLoading = false;
    mNumLodLevel = 0;
 
    mMesh = SBaseMeshsTools::CreateOctahedron(mResourceName, base, bottom, dist, mGroupName);
    O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, mResourceName, groupName);
    CommonConstructorsSequence();
  }
 
  SEntity::SEntity() : SNode(0, "", SNode::ENTITY_TYPE_ID)
  {
    // Forbiden (private)
  }
 
  void SEntity::BuildMissingComponents()
  {
    //needed for D3D11
    if (mMesh->getSubMesh(0) && mMesh->getSubMesh(0)->vertexData)
    {
      if (SRoot::getSingleton().GetRenderSystem() == SRoot::SO3_DIRECTX11_RENDERER)
      {
        for (unsigned int i = 0; i < mMesh->getNumSubMeshes(); i++)
        {
          Ogre::SubMesh* smesh = mMesh->getSubMesh(i);
          Ogre::VertexData* vdata = smesh->vertexData;
          if (vdata && !vdata->vertexDeclaration->findElementBySemantic(Ogre::VertexElementSemantic::VES_TEXTURE_COORDINATES))
          {
            unsigned short src = vdata->vertexDeclaration->getMaxSource();
            Ogre::HardwareVertexBufferSharedPtr origBuffer = vdata->vertexBufferBinding->getBuffer(src);
            unsigned int vcnt = origBuffer->getVertexSize();
 
            src += 1;
            Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
            vdata->vertexDeclaration->addElement(src, 0, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES);
 
            auto tvbuf = mMesh->getHardwareBufferManager()->createVertexBuffer(vcnt + 2 * sizeof(float), vdata->vertexCount, origBuffer->getUsage(), origBuffer->hasShadowBuffer());
 
            // Bind buffer
            Ogre::VertexBufferBinding* vBind = vdata->vertexBufferBinding;
            vBind->setBinding(src, tvbuf);
 
            // Set up basic tex coordinates
            Ogre::HardwareVertexBufferSharedPtr vbuf = vdata->vertexBufferBinding->getBuffer(src);
            Ogre::HardwareBufferLockGuard vbufLock(vbuf, Ogre::HardwareBuffer::HBL_DISCARD);
            float* pFloat = static_cast<float*>(vbufLock.pData);
 
            if (smesh->operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST)
            {
              for (unsigned int i = 0; i < (vcnt / 3); i++)
              {
                *pFloat++ = 0.0f;
                *pFloat++ = 0.0f;
                *pFloat++ = 0.0f;
                *pFloat++ = 1.0f;
                *pFloat++ = 1.0f;
                *pFloat++ = 1.0f;
              }
            }
            else
            {
              for (unsigned int i = 0; i < vcnt; i++)
              {
                *pFloat++ = 0.0f;
                *pFloat++ = 0.0f;
              }
            }
          }
        }
      }
 
      const Ogre::VertexElement* hasTangent = mMesh->getSubMesh(0)->vertexData->vertexDeclaration->findElementBySemantic(Ogre::VertexElementSemantic::VES_TANGENT);
      if (hasTangent)
        return;
 
      try
      {
        // build tangent vectors for our mesh
        unsigned short src;
        if (mMesh->suggestTangentVectorBuildParams(src))
        {
          mMesh->buildTangentVectors(src);
          // this version cleans mirrored and rotated UVs but requires quality models
          //mesh->buildTangentVectors(src, true, true);
        }
      }
      catch (Ogre::Exception &e)
      {
        Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
      }
    }
  }
 
  void SEntity::CommonConstructorsSequence()
  {
    assert(O3Entity != 0);
    ogreMovableObject = O3Entity;
 
    //add missing UV
    BuildMissingComponents();
 
    //$BB removed, this break some mesh normals
    /*
    bool lastLogstate = SRoot::getSingletonPtr()->GetLogEnable();
    SRoot::getSingletonPtr()->SetLogEnable(false);
 
    try
    {
      // build tangent vectors for our mesh
      unsigned short src, dest;
      if (!mMesh->suggestTangentVectorBuildParams(Ogre::VES_TANGENT, src, dest))
      {
        mMesh->buildTangentVectors(Ogre::VES_TANGENT, src, dest);
        // this version cleans mirrored and rotated UVs but requires quality models
        //mesh->buildTangentVectors(VES_TANGENT, src, dest, true, true);
      }
    }
    catch(Ogre::Exception &e)
    {
      tmpRoot->SetLogEnable(lastLogstate);
 
      // Catching Exception::ERR_ITEM_NOT_FOUND. Forwarding other errors.
      if(e.getNumber() != Ogre::Exception::ERR_ITEM_NOT_FOUND)
      {
        Ogre::LogManager::getSingletonPtr()->logMessage(e.getFullDescription(), Ogre::LML_CRITICAL, true);
        throw e;
      }
    }
 
    SRoot::getSingletonPtr()->SetLogEnable(lastLogstate);
    */
 
    // Build mesh edge list for stencil shadows. (take long)
    /*if(!mMesh->isEdgeListBuilt())
    {
      mMesh->freeEdgeList();
      mMesh->buildEdgeList();
    }*/
 
    O3SceneNode->attachObject(O3Entity);
 
    //check if a parent is hidden
    bool visible = GetVisible();
    SNode* parent = GetParentSceneNode();
    while (visible && parent != NULL)
    {
      visible = parent->GetVisible();
      parent = parent->GetParentSceneNode();
    }
 
    if(!visible)
      SetVisible(false, false);
 
    // Create SO3VertexAnimation
    if (O3Entity->hasVertexAnimation())
    {
      // Loading Animation
      int numAnimations = mMesh->getNumAnimations();
      for (int i = 0; i < numAnimations; i++)
      {
        Ogre::Animation* ogreAnimation = mMesh->getAnimation(i);
 
        // Pose animation or standard vertex animation?
        // NB that pose name is the same as animation name in case of a pose animation.
        SAnim* animation = 0;
        PoseHandleList::iterator iPoseAnim = poseHandleList.find(ogreAnimation->getName());
        if (iPoseAnim != poseHandleList.end())
          animation = new SPoseAnimation(GetParentScene(), ogreAnimation->getName(), this, animationCounter++, iPoseAnim->second);
        else
          animation = new SVertexAnimation(GetParentScene(), ogreAnimation->getName(), this, animationCounter++);
 
        AddAnimation(animation);
      }
    }
 
    // Bind this instance to every subentity of the entity (used in SEntitySelectorMaterialSwitcher).
    int numSubEntities = O3Entity->getNumSubEntities();
 
    for (int iSubEntities = 0; iSubEntities < numSubEntities; iSubEntities++)
    {
      Ogre::SubEntity* sEnt = O3Entity->getSubEntity(iSubEntities);
      // If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
      static_cast <Ogre::Renderable*> (sEnt)->setUserAny(Ogre::Any(this));
#else
      sEnt->getUserObjectBindings().setUserAny("SEntity", Ogre::Any(this));
#endif
      SMaterial* sMat = GetParentScene()->GetMaterial(mGroupName, sEnt->getMaterialName());
      if (sMat == 0)
        try
      {
        sMat = GetParentScene()->CreateMaterial(mGroupName, sEnt->getMaterialName());
        sEnt->setMaterial(sMat->getOgreMaterialPointer());
      }
      catch (SException&)
      {
        MMechostr(MSKDEBUG, ">>>> Error on Material entity : %s\n", sEnt->getMaterialName().c_str());
      }
    }
  }
 
  SEntity::~SEntity()
  {
    // avoid a crash on scol close
    DetachFromParent();
 
    if (mMesh)
      mMesh->removeListener(this);
 
    if (entitySKL)
    {
      currentScene->DeleteSkeleton(entitySKL);
      //O3Entity->stopSharingSkeletonInstance();
      entitySKL = 0;
    }
 
    if (O3Entity)
    {
      O3SceneNode->detachObject(O3Entity);
      currentScene->GetOgreScenePointer()->destroyEntity(O3Entity);
    }
 
    //for unknown reason the use count = 4 just at load time
    if (mMesh && ((mMesh.use_count() <= 4) || mReleaseResource))
    {
      if (mMesh->isLoaded())
        mMesh->unload();
    
      Ogre::MeshManager::getSingleton().remove(mMesh->getHandle());
      mMesh.reset();
    }
 
    O3Entity = 0;
    ogreMovableObject = 0;
  }
 
  void SEntity::SetFreeResource(bool state)
  {
    mReleaseResource = state;
  }
 
  Ogre::Entity* SEntity::getOgreEntityPointer()
  {
    return O3Entity;
  }
 
  SSkeleton* SEntity::GetSkeleton()
  {
    return entitySKL;
  }
 
  std::string SEntity::GetGroupName()
  {
    return mGroupName;
  }
 
  void SEntity::SetCastShadows(const bool& castShadows)
  {
    if (O3Entity)
      O3Entity->setCastShadows(castShadows);
  }
 
  bool SEntity::GetCastShadows()
  {
    if (O3Entity)
      return O3Entity->getCastShadows();
    else
      return false;
  }
 
  void SEntity::SetRenderingDistance(const float& distance)
  {
    if (O3Entity)
      O3Entity->setRenderingDistance(distance);
  }
 
  float SEntity::GetRenderingDistance()
  {
    if (O3Entity)
      return O3Entity->getRenderingDistance();
    else
      return 0.0f;
  }
 
  Ogre::Vector3 SEntity::GetBoundingBoxSize(const bool& childs)
  {
    if (childs)
      return GetSonsBoundingBox();
 
    Ogre::Vector3 scale = GetGlobalScale();
 
    if (O3Entity)
      return (O3Entity->getBoundingBox().getSize() * scale);
    else
      return Ogre::Vector3(1.0f, 1.0f, 1.0f) * scale;
  }
 
  Ogre::Vector3 SEntity::GetBoundingBoxCenter(const bool& childs)
  {
    Ogre::Vector3 scale = GetGlobalScale();
    if (O3Entity)
      return (O3Entity->getBoundingBox().getCenter() * scale);
    else
      return Ogre::Vector3(0.0f, 0.0f, 0.0f);
  }
 
  Ogre::Vector3 SEntity::GetWorldBoundingBoxSize(const bool& childs)
  {
    if (childs)
      return GetSonsWorldBoundingBox();
 
    Ogre::Vector3 scale = GetGlobalScale();
 
    if (O3Entity)
      return O3Entity->getWorldBoundingBox(true).getSize();
    else
      return Ogre::Vector3(1.0f, 1.0f, 1.0f) * scale;
  }
 
  Ogre::Vector3 SEntity::GetWorldBoundingBoxCenter(const bool& childs)
  {
    if (O3Entity)
      return O3Entity->getWorldBoundingBox(true).getCenter();
    else
      return Ogre::Vector3(0.0f, 0.0f, 0.0f);
  }
 
  unsigned int SEntity::GetPolygonCount()
  {
    unsigned int count = 0;
    if (mMesh && mMesh->isLoaded())
    {
      for (unsigned short i = 0; i < mMesh->getNumSubMeshes(); ++i)
      {
        Ogre::SubMesh* submesh = mMesh->getSubMesh(i);
        count += submesh->indexData->indexCount;
      }
    }
 
    return count / 3;
  }
 
  unsigned int SEntity::GetVerticesCount()
  {
    unsigned int count = 0;
    if (mMesh && mMesh->isLoaded())
    {
      for (unsigned short i = 0; i < mMesh->getNumSubMeshes(); ++i)
      {
        Ogre::SubMesh* submesh = mMesh->getSubMesh(i);
        // We only need to add the shared vertices once
        if (submesh->useSharedVertices)
        {
          count += mMesh->sharedVertexData->vertexCount;
          break;
        }
        else
        {
          count += submesh->vertexData->vertexCount;
        }
      }
    }
 
    return count;
  }
 
  void SEntity::SetRenderQueue(const Ogre::RenderQueueGroupID& groupId)
  {
    if (O3Entity)
      O3Entity->setRenderQueueGroup(groupId);
  }
 
  unsigned int SEntity::GetNumSubEntities()
  {
    if (O3Entity)
      return O3Entity->getNumSubEntities();
    else
      return 0;
  }
 
  void SEntity::SetVisibilityFlags(const Ogre::uint32& flags)
  {
    if (O3Entity)
      O3Entity->setVisibilityFlags(flags);
  }
 
  Ogre::uint32 SEntity::GetVisibilityFlags()
  {
    if (O3Entity)
      return O3Entity->getVisibilityFlags();
    else
      return 0xffffff;
  }
 
  void SEntity::SetVisibilityFlagIndexEnable(const Ogre::uint32& flagIndex, bool enable)
  {
    if (O3Entity)
    {
      assert((flagIndex > 0) && (flagIndex < 32));
      Ogre::uint32 flag = 1 << flagIndex;
      if (enable)
        O3Entity->addVisibilityFlags(flag);
      else
        O3Entity->removeVisibilityFlags(flag);
    }
  }
 
  bool SEntity::GetVisibilityFlagIndexEnable(const Ogre::uint32& flagIndex)
  {
    if (O3Entity)
    {
      assert((flagIndex > 0) && (flagIndex < 32));
      // Declare a uint32 variable to be sure that the binary AND will be done on the same variable length as the var returned by getVisibilityFlags.
      Ogre::uint32 flag = 1 << flagIndex;
      if ((flag & O3Entity->getVisibilityFlags()) > 0)
        return true;
      else
        return false;
    }
    else
      return true;
  }
 
  void SEntity::_SetSkeleton(SSkeleton* newSkeleton)
  {
    entitySKL = newSkeleton;
  }
 
  void SEntity::GenerateLOD(int nbLevels)
  {
    mNumLodLevel = nbLevels;
    if (O3Entity)
    {
      int curLevels = O3Entity->getMesh()->getNumLodLevels();
      if ((curLevels == nbLevels) || (curLevels == 1 && nbLevels == 0))
        return;
 
      if ((nbLevels == 0) && (curLevels != nbLevels))
      {
        O3Entity->getMesh()->removeLodLevels();
        return;
      }
 
      //reset LOD
      O3Entity->getMesh()->removeLodLevels();
      Ogre::LodConfig lodConfig;
      lodConfig.levels.clear();
      lodConfig.mesh = O3Entity->getMesh();
      lodConfig.strategy = Ogre::ScreenRatioPixelCountLodStrategy::getSingletonPtr();
      lodConfig.advanced.useCompression = true;
      lodConfig.advanced.useVertexNormals = true;
      lodConfig.advanced.useBackgroundQueue = mLoading;
      //lodConfig.advanced.preventPunchingHoles = true;
      //lodConfig.advanced.preventBreakingLines = true;
 
      int nbl = nbLevels + 2;
      Ogre::Real reduction = 0.7f / nbLevels;
      for (int i = 2; i < nbl; i++)
      {
        Ogre::Real i4 = (Ogre::Real)(i * i * i * i);
        lodConfig.createGeneratedLodLevel(2.0 / i4, reduction * i, Ogre::LodLevel::VRM_PROPORTIONAL);
      }
 
      Ogre::MeshLodGenerator::getSingleton().generateLodLevels(lodConfig);
    }
  }
 
  //TODO apply subentities material
  // need to reload animations / skeleton ?
  void SEntity::Reload()
  {
    if (O3Entity)
    {
      // Bind this instance to every subentity of the entity (used in SEntitySelectorMaterialSwitcher).
      int numSubEntities = O3Entity->getNumSubEntities();
 
      for (int iSubEntities = 0; iSubEntities < numSubEntities; iSubEntities++)
      {
        Ogre::SubEntity* sEnt = O3Entity->getSubEntity(iSubEntities);
        // If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
        static_cast <Ogre::Renderable*> (sEnt)->setUserAny(Ogre::Any(this));
#else
        sEnt->getUserObjectBindings().setUserAny("SEntity", Ogre::Any(this));
#endif
        SMaterial* sMat = GetParentScene()->GetMaterial(mGroupName, sEnt->getMaterialName());
        if (sMat == 0)
          try
        {
          sMat = GetParentScene()->CreateMaterial(mGroupName, sEnt->getMaterialName());
          sEnt->setMaterial(sMat->getOgreMaterialPointer());
        }
        catch (SException&)
        {
        }
      }
    }
  }
 
  bool SEntity::SetMaterial(SMaterial* mat, int subindex)
  {
    if (!O3Entity)
      return false;
 
    try
    {
      if (subindex < 0)
      {
        O3Entity->setMaterialName(mat->GetName(), mat->GetGroupName());
      }
      else if (subindex < (int)O3Entity->getNumSubEntities())
      {
        O3Entity->getSubEntity(subindex)->setMaterialName(mat->GetName(), mat->GetGroupName());
      }
      else
        return false;
    }
    catch (Ogre::Exception &)
    {
      //material not supported
      return false;
    }
 
    return true;
  }
 
  void SEntity::SetMinPixelSize(const float &minsize)
  {
    if (!O3Entity)
      return;
 
    O3Entity->setRenderingMinPixelSize(minsize);
  }
 
  float SEntity::GetMinPixelSize()
  {
    if (!O3Entity)
      return 0.0f;
 
    return O3Entity->getRenderingMinPixelSize();
  }
 
}