SO3Engine/SO3SceneGraph/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) 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 "SO3Scene.h"
#include "SO3Entity.h"
#include "SO3Skeleton.h"
#include "../SO3Animation/SO3VertexAnimation.h"
#include "../SO3Animation/SO3PoseAnimation.h"
#include "../SO3Material/SO3Material.h"

namespace SO3
{

SEntity::SEntity(SScene* parent, std::string groupName, std::string entityName, std::string meshName) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
{
  entitySKL = 0;
  mGroupName = groupName;
  mReleaseResource = false;
  mResourceName = meshName;

  //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.isNull())
        {
          mMesh = Ogre::MeshManager::getSingleton().load(meshName, mGroupName);
          if(mMesh->hasSkeleton())
          {
                  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");
  }

  // 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(mMesh->getPoseCount() > 0)
  {
    Ogre::ushort cptPose = 0;
    Ogre::Mesh::PoseIterator iPoseList = mMesh->getPoseIterator();
    while(iPoseList.hasMoreElements())
    {
      Ogre::Pose* pose = iPoseList.getNext();
      Ogre::Animation* ogreAnimation = 0;

      // Reformat name if necessary
      std::string animationName = pose->getName();
      std::string poseTargetAsString = boost::lexical_cast<std::string, Ogre::ushort> (pose->getTarget());
      if(animationName.substr(animationName.length()-poseTargetAsString.length(), poseTargetAsString.length()) == poseTargetAsString)
        animationName = animationName.substr(0, animationName.length()-poseTargetAsString.length());

      if(!mMesh->hasAnimation(animationName))
      {
        // 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!");

        // Animation do not exist, create a manual animation
        ogreAnimation = mMesh->createAnimation(animationName, 0);

        // Create track and keyframe
        Ogre::VertexPoseKeyFrame* ogreKeyFrame = ogreAnimation->createVertexTrack(pose->getTarget(), Ogre::VAT_POSE)->createVertexPoseKeyFrame(0);

        // Link animation key frame to the pose reference
        ogreKeyFrame->addPoseReference(cptPose, 0.0f);

        // 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, cptPose));

      // Increment pose index
      cptPose++;
    }
  }
  
  O3Entity = currentScene->GetOgreScenePointer()->createEntity(entityName, meshName, groupName);
  CommonConstructorsSequence();
}

SEntity::SEntity(SScene* parent, std::string entityName, EntityPrefabType prefabType) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
{
  entitySKL = 0;
  mGroupName = "General";
  mReleaseResource = false;
  mResourceName = "";
  mMesh.setNull();

  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, std::string groupName, std::string entityName, SPointFloat sizev, SPointInt seg, SPointFloat uv) : SNode(parent, entityName, SNode::ENTITY_TYPE_ID)
{
  entitySKL = 0;
  mGroupName = groupName;
  mReleaseResource = true;
  mResourceName = groupName + entityName + ".PlaneRes";

  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();
}

SEntity::SEntity() : SNode(0, "", SNode::ENTITY_TYPE_ID)
{
  // Forbiden (private)
}

void SEntity::CommonConstructorsSequence()
{
  assert(O3Entity != 0);
  ogreMovableObject = O3Entity;

  // Build mesh edge list for stencil shadows.
  if(!mMesh->isEdgeListBuilt())
  {
    mMesh->freeEdgeList();
    mMesh->buildEdgeList();
  }
  O3SceneNode->attachObject(O3Entity);

  // 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, i, iPoseAnim->second);
      else
        animation = new SVertexAnimation(GetParentScene(), ogreAnimation->getName(), this, i);

      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)
      sMat = GetParentScene()->CreateMaterial(mGroupName, sEnt->getMaterialName());

    sEnt->setMaterial(sMat->getOgreMaterialPointer());
  }
}

SEntity::~SEntity()
{
  // avoid a crash on scol close
  DetachFromParent();

  if(entitySKL)
  {
    currentScene->DeleteSkeleton(entitySKL);
    entitySKL = 0;
  }
  
  O3SceneNode->detachObject(O3Entity);
  currentScene->GetOgreScenePointer()->destroyEntity(O3Entity);
  
  if (mReleaseResource && !mMesh.isNull())
  {
    Ogre::MeshManager::getSingleton().remove(mMesh->getHandle());
    mMesh.setNull();
  }

  O3Entity = 0;
  ogreMovableObject = 0;
}

Ogre::Entity* SEntity::getOgreEntityPointer() 
{
        return O3Entity;
}

SSkeleton* SEntity::GetSkeleton() 
{
        return entitySKL;
}

std::string SEntity::GetGroupName()
{
  return mGroupName;
}

void SEntity::getSubMeshVertices(std::vector<Ogre::Vector3>* vertices,unsigned int index, Ogre::MeshPtr curMesh)
{
        if(this != NULL)
        {
                Ogre::VertexData* vertex_data = curMesh->getSubMesh(index)->useSharedVertices ? curMesh->sharedVertexData : curMesh->getSubMesh(index)->vertexData;
                const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
                Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
                unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
                float* pReal;
                vertices->resize(vertex_data->vertexCount);

                for (size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
                {
                        posElem->baseVertexPointerToElement(vertex, &pReal);
                        (*vertices)[j] = Ogre::Vector3(pReal[0],pReal[1],pReal[2]);
                }
                vbuf->unlock();
        }
}

void SEntity::SetCastShadows(bool castShadows)
{
  O3Entity->setCastShadows(castShadows);
}

bool SEntity::GetCastShadows()
{
  return O3Entity->getCastShadows();
}

void SEntity::SetRenderingDistance(float distance)
{
  return O3Entity->setRenderingDistance(distance);
}

float SEntity::GetRenderingDistance()
{
  return O3Entity->getRenderingDistance();
}

Ogre::Vector3 SEntity::GetBoundingBoxSize(bool childs)
{
  if (childs)
    return GetSonsBoundingBox();
  
  Ogre::Vector3 scale = O3SceneNode->_getDerivedScale();
  return (O3Entity->getBoundingBox().getSize() * scale);
}

Ogre::Vector3 SEntity::GetBoundingBoxCenter(bool childs)
{
  Ogre::Vector3 scale = O3SceneNode->_getDerivedScale();        
  return (O3Entity->getBoundingBox().getCenter() * scale);
}

unsigned int SEntity::GetPolygonCount()
{
  return O3Entity->getEdgeList()->triangles.size();
}

void SEntity::SetRenderQueue(Ogre::RenderQueueGroupID groupId)
{
  O3Entity->setRenderQueueGroup(groupId);
}

unsigned int SEntity::GetNumSubEntities()
{
  return O3Entity->getNumSubEntities();
}

void SEntity::SetVisibilityFlags(Ogre::uint32 flags)
{
  O3Entity->setVisibilityFlags(flags);
}

Ogre::uint32 SEntity::GetVisibilityFlags()
{
  return O3Entity->getVisibilityFlags();
}

void SEntity::_SetSkeleton(SSkeleton* newSkeleton)
{
  entitySKL = newSkeleton;
}

//TODO apply subentities material
// need to reload animations / skeleton ?
void SEntity::Reload()
{
  // 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)
      sMat = GetParentScene()->CreateMaterial(mGroupName, sEnt->getMaterialName());

    sEnt->setMaterial(sMat->getOgreMaterialPointer());
  }
}

}

---