SO3NodeScol.cpp

Go to the documentation of this file.

 
// using scolSDK
#include "SO3SceneGraph/SO3NodeScol.h"
#include "SO3SceneGraph/SO3Entity.h"
#include "SO3SceneGraph/SO3Light.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Bone.h"
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3Animation/SO3NodeAnimation.h"
#include "SO3PhysicGraph/SO3Body.h"
#include "SO3PhysicGraph/SO3Shape.h"
#include "SO3PhysicGraph/SO3ShapeBox.h"
#include "SO3PhysicGraph/SO3ShapeCone.h"
#include "SO3PhysicGraph/SO3ShapeEllipsoid.h"
#include "SO3PhysicGraph/SO3ShapeCapsule.h"
#include "SO3PhysicGraph/SO3ShapeCylinder.h"
#include "SO3PhysicGraph/SO3ShapeChamferCylinder.h"
#include "SO3PhysicGraph/SO3ShapePyramid.h"
#include "SO3PhysicGraph/SO3ShapeConvexHull.h"
#include "SO3PhysicGraph/SO3ShapeConcaveHull.h"
#include "SO3PhysicGraph/SO3ShapeTree.h"
 
namespace SO3
{
 
SNode::SNode() : SData(""), type(SNode::NODE_TYPE_ID)
{
  // Forbiden (private)
}
 
SNode::SNode(SScene* parent, const std::string& nodeName, const bool& isRootNode) : SData(nodeName), currentScene(parent), type(SNode::NODE_TYPE_ID)
{
        nodeBody = 0;
  staticGeometry = 0;
  ogreMovableObject = 0;
  staticVisibility = true;
        isForeGround = false;
        isMouseClick = true;
  mIsDirty = true;
        mouseFlags = SO3_OBJECT_MOUSE_ENABLE;
  mFlags = 0;
  animationCounter = 0;
  mPhysicsOverride = false;
  mVisible = true;
 
        initialPosition = Ogre::Vector3::ZERO;
  initialOrientation = Ogre::Quaternion::IDENTITY;
        initialScale = Ogre::Vector3::UNIT_SCALE;
  autoTrackTargetNode = 0;
 
  nodeFather = 0;
  if (isRootNode)
  {
    O3SceneNode = currentScene->GetOgreScenePointer()->getRootSceneNode();
  }
  else
  {
    SNode* rootNode = currentScene->GetRootNode();
    O3SceneNode = currentScene->GetOgreScenePointer()->createSceneNode(name);
    AttachToParent(rootNode);
  }
 
// If our ogre is anterior to v1.7
#if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
  // Bind our instance to Ogre::SceneNode.
  O3SceneNode->setUserAny(Ogre::Any(this));
#else
  // Bind our instance to Ogre::SceneNode.
  O3SceneNode->getUserObjectBindings().setUserAny("SNode", Ogre::Any(this));
#endif
}
 
SNode::SNode(SScene* parent, const std::string& nodeName, const NodeType& nodeType) : SData(nodeName), currentScene(parent), type(nodeType)
{
  ogreMovableObject = 0;
  staticGeometry = 0;
  nodeBody = 0;
  staticVisibility = true;
        isForeGround = false;
        isMouseClick = true;
        mouseFlags = SO3_OBJECT_MOUSE_ENABLE;
  mFlags = 0;
  mVisible = true;
 
        initialPosition = Ogre::Vector3::ZERO;
  initialOrientation = Ogre::Quaternion::IDENTITY;
        initialScale = Ogre::Vector3::UNIT_SCALE;
  autoTrackTargetNode = 0;
  animationCounter = 0;
 
  nodeFather = 0;
  // Hack
  if (type == SKELETON_TYPE_ID)
  {
    O3SceneNode = 0;
  }
  else
  {
    SNode* rootNode = currentScene->GetRootNode();
    O3SceneNode = currentScene->GetOgreScenePointer()->createSceneNode(name);
    AttachToParent(rootNode);
 
  // If our ogre is anterior to v1.7
  #if OGRE_VERSION < ((1 << 16) | (7 << 8) | 0)
    // Bind our instance to Ogre::SceneNode.
    O3SceneNode->setUserAny(Ogre::Any(this));
  #else
    // Bind our instance to Ogre::SceneNode.
    O3SceneNode->getUserObjectBindings().setUserAny("SNode", Ogre::Any(this));
  #endif
  }
}
 
SNode::~SNode()
{
  SetAsStaticGeometry(false);
 
  // detach from parent.
  DetachFromParent();
 
  // detach all children nodes before deleting this.
  // sons are destroyed with Scol object callback
  SNodeMap childNodeListCopy = childNodeList;
  SNodeMap::iterator iChildNodeListCopy = childNodeListCopy.begin();
  while (iChildNodeListCopy != childNodeListCopy.end())
  {
    iChildNodeListCopy->second->DetachFromParent();
    iChildNodeListCopy++;
  }
 
  // Erase all anims
  const SAnimMap animationListCopy = GetAnimations();
  SAnimMap::const_iterator iAnimation = animationListCopy.begin();
  while(iAnimation != animationListCopy.end())
  {
    DeleteAnimation(iAnimation->second);
    iAnimation++;
  }
 
  if (O3SceneNode)
  {
    SetAutoTracking(false); // Suppress autotracking to avoid crash
 
    // Do not destroy scene root node!!!
    if (this != currentScene->GetRootNode())
    {
      currentScene->GetOgreScenePointer()->destroySceneNode(O3SceneNode);
      O3SceneNode = 0;
    }
  }
 
  //must be destroy by scol
        assert(nodeBody == 0);
  nodeBody = 0;
}
 
Ogre::SceneNode* SNode::GetOgreSceneNodePointer()
{
        return O3SceneNode;
}
 
Ogre::MovableObject* SNode::GetMovableObjectPointer()
{
        return ogreMovableObject;
}
 
void SNode::SetFlags(const int& flags)
{
  mFlags = flags;
}
 
int SNode::GetFlags()
{
  return mFlags;
}
 
bool SNode::GetSceneNodeIsMouseForeground()
{
        return isForeGround;
}
 
void SNode::SetSceneNodeIsMouseForeground(const bool& mForeground)
{
  isForeGround = mForeground;
}
 
bool  SNode::GetSceneNodeIsMouseClick()
{
        return isMouseClick;
}
 
void  SNode::SetSceneNodeIsMouseClick(const bool& mClickable)
{
        isMouseClick = mClickable;
}
 
int  SNode::GetSceneNodeMouseFlags()
{
        return mouseFlags;
}
 
void  SNode::SetSceneNodeMouseFlags(const int& flags)
{
        mouseFlags = flags;
}
 
bool  SNode::GetSceneNodeHasBody()
{
        return nodeBody != 0;
}
 
SBody* SNode::GetSceneNodeBody()
{
  return nodeBody;
}
 
// $BB TODO update the body shape scale on object scale change
void SNode::UpdateNodeBody(const bool& bScale)
{
  //$BB add the new initial position to node
  /*if(!currentScene->GetPhysicWorldEnable())
  {
    StoreInitialPRS();
  }*/
 
  //$BB setPositionOrientation make an update body in newton wrapper but we need to use it to keep the good PRS in body class
  //$BB test with added setPositionOrientationFromNode
 
  // we need to update all the parent hierarchy to get the correct global values.
  if (O3SceneNode && mIsDirty)
  {
    O3SceneNode->_update(false, true);
    SetDirty(false);
  }
 
  if(nodeBody!=NULL)
  {
    if(O3SceneNode && type == BONE_TYPE_ID)
    {
      SBone* bone = static_cast<SBone*>(this);
      nodeBody->UpdatePositionOrientation(bone->GetGlobalPosition(), bone->GetGlobalOrientation());
 
      if (bScale)
        nodeBody->SetScale(bone->GetGlobalScale());
 
      if (IsAnimated())
      {
        nodeBody->SetVelocity(Ogre::Vector3::ZERO);
        nodeBody->SetOmega(Ogre::Vector3::ZERO);
      }
    }
    else
    {
      //O3SceneNode->_update(true, true);
      nodeBody->UpdatePositionOrientation();
 
      if (bScale)
        nodeBody->SetScale(GetGlobalScale());
    }
  }
 
  SNodeMap::iterator iNodeChildList = childNodeList.begin();
  while (iNodeChildList != childNodeList.end())
  {
    iNodeChildList->second->UpdateNodeBody(bScale);
    iNodeChildList++;
  }
}
 
void SNode::DisableAutoTarget()
{
  SNodeMap::const_iterator iNodeList = currentScene->GetNodeList().begin();
  while (iNodeList != currentScene->GetNodeList().end())
  {
    SNode* currentNode = iNodeList->second;
    if(currentScene->O3SceneManager->hasSceneNode(currentNode->name))
    {
      //Ogre::SceneNode* target = currentNode->getOgreSceneNodePointer()->getAutoTrackTarget();
      SNode* target = currentNode->GetAutoTrackingTarget();
      if(target)
      {
        if(target->GetName() == currentNode->GetName())
        {
          currentNode->SetAutoTracking(false);
        }
      }
    }
    iNodeList++;
  }
}
 
SScene* SNode::GetParentScene()
{
  return currentScene;
}
 
SNode::NodeType SNode::GetNodeType()
{
  return type;
}
 
void SNode::AttachToParent(SNode* newParentNode)
{
  //can't attach a node to himself!
  if (newParentNode == this)
    return;
 
  // test if the new father is a child
  // in this case the new parent is detached first
  SNodeMap::iterator iNodeSearched = childNodeList.find(newParentNode->GetName());
  if (iNodeSearched != childNodeList.end())
  {
    iNodeSearched->second->DetachFromParent();
  }
 
  DetachFromParent();
 
  if (nodeFather && nodeFather->GetNodeType() == SNode::BONE_TYPE_ID)
  {
    SBone* boneFather = static_cast <SBone*> (nodeFather);
    boneFather->AttachToBone(this);
  }
 
  newParentNode->AddChildNode(this);
  nodeFather = newParentNode;
  SetDirty(true);
 
  UpdateNodeBody(true);
}
 
void SNode::DetachFromParent()
{
  if (nodeFather != 0)
  {
    if (nodeFather->GetNodeType() == SNode::BONE_TYPE_ID)
    {
      SBone* boneFather = static_cast <SBone*> (nodeFather);
      boneFather->DetachFromBone(this);
    }
 
    nodeFather->RemoveChildNode(this);
    nodeFather = 0;
  }
}
 
SNode* SNode::GetParentSceneNode()
{
  return nodeFather;
}
 
const SNodeMap SNode::GetChildrenNodes() const
{
  return childNodeList;
}
 
int SNode::GetNumChildren()
{
  return O3SceneNode->numChildren();
}
 
void SNode::DetachAllChildren()
{
  const SNodeMap childNodeListCopy = childNodeList;
  SNodeMap::const_iterator iChildNodeList = childNodeListCopy.begin();
  while (iChildNodeList != childNodeListCopy.end())
  {
    iChildNodeList->second->DetachFromParent();
    iChildNodeList++;
  }
}
 
void SNode::AddChildNode(SNode* newChild)
{
  string nodeName = newChild->GetName();
  SNodeMap::iterator iNodeSearched = childNodeList.find(nodeName);
  if (iNodeSearched == childNodeList.end())
  {
    Ogre::SceneNode* ogreNewChild = newChild->GetOgreSceneNodePointer();
    if (ogreNewChild->getParentSceneNode() != O3SceneNode)
      O3SceneNode->addChild(ogreNewChild);
 
    childNodeList.insert(SNodeMap::value_type(nodeName, newChild));
  }
  else
  {
    // Node already exist in the handled nodes list.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add node named \""+ nodeName +"\", an element with the same name already exist!", "SNode::AddChildNode");
  }
}
 
void SNode::RemoveChildNode(SNode* existingChild)
{
  string nodeName = existingChild->GetName();
  SNodeMap::iterator iNodeSearched = childNodeList.find(nodeName);
  if (iNodeSearched != childNodeList.end())
  {
    // Special case for skeleton for example.
    if (O3SceneNode != 0)
    {
      try
      {
        O3SceneNode->removeChild(existingChild->GetOgreSceneNodePointer());
      }
      catch(Ogre::Exception &)
      {
        //must been in static geometry
      }
    }
 
    childNodeList.erase(iNodeSearched);
  }
  else
  {
    // Node not found in the handled nodes list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Node named \""+ nodeName +"\", element not found!", "SNode::RemoveChildNode");
  }
}
 
void SNode::SetCastShadows(const bool& castShadows)
{
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "This SNode object do not manage Shadow Casting!", "SNode::SetCastShadows");
}
 
bool SNode::GetCastShadows()
{
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "This SNode object do not manage Shadow Casting!", "SNode::GetCastShadows");
  return false;
}
 
void SNode::SetRenderingDistance(const float& distance)
{
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "This SNode object do not manage Rendering distance!", "SNode::SetRenderingDistance");
}
 
float SNode::GetRenderingDistance()
{
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "This SNode object do not manage Rendering distance!", "SNode::GetRenderingDistance");
  return 0.0;
}
 
Ogre::Vector3 SNode::GetBoundingBoxSize(const bool& childs)
{
  if (childs)
    return GetSonsBoundingBox();
 
  throw std::logic_error("SNode::GetBoundingBoxSize : This SNode object do not manage any bounding box!");
  return Ogre::Vector3::ZERO;
}
 
Ogre::Vector3 SNode::GetBoundingBoxCenter(const bool& childs)
{
  throw std::logic_error("SNode::GetBoundingBoxSize : This SNode object do not manage any bounding box!");
  return Ogre::Vector3::ZERO;
}
 
Ogre::Vector3 SNode::GetWorldBoundingBoxSize(const bool& childs)
{
  if (childs)
    return GetSonsWorldBoundingBox();
 
  throw std::logic_error("SNode::GetWorldBoundingBoxSize : This SNode object do not manage any bounding box!");
  return Ogre::Vector3::ZERO;
}
 
Ogre::Vector3 SNode::GetWorldBoundingBoxCenter(const bool& childs)
{
  throw std::logic_error("SNode::GetWorldBoundingBoxCenter : This SNode object do not manage any bounding box!");
  return Ogre::Vector3::ZERO;
}
 
Ogre::Vector3 SNode::GetSonsBoundingBox()
{
  Ogre::Vector3 bbox(Ogre::Vector3::ZERO);
  try
  {
    bbox = GetBoundingBoxSize();
  }
  catch (std::exception)
  {
    bbox = Ogre::Vector3::ZERO;
  }
 
  Ogre::Vector3 tbox(Ogre::Vector3::ZERO);
 
  SNodeMap::iterator iChildNodeList = childNodeList.begin();
  while (iChildNodeList != childNodeList.end())
  {
    tbox = iChildNodeList->second->GetSonsBoundingBox();
    if (tbox.x > bbox.x)
      bbox.x = tbox.x;
    if (tbox.y > bbox.y)
      bbox.y = tbox.y;
    if (tbox.z > bbox.z)
      bbox.z = tbox.z;
 
    iChildNodeList++;
  }
 
  return bbox;
}
 
Ogre::Vector3 SNode::GetSonsWorldBoundingBox()
{
  Ogre::Vector3 bbox(Ogre::Vector3::ZERO);
  try
  {
    bbox = GetWorldBoundingBoxSize();
  }
  catch (std::exception)
  {
    bbox = Ogre::Vector3::ZERO;
  }
 
  Ogre::Vector3 tbox(Ogre::Vector3::ZERO);
 
  SNodeMap::iterator iChildNodeList = childNodeList.begin();
  while (iChildNodeList != childNodeList.end())
  {
    tbox = iChildNodeList->second->GetSonsWorldBoundingBox();
    if (tbox.x > bbox.x)
      bbox.x = tbox.x;
    if (tbox.y > bbox.y)
      bbox.y = tbox.y;
    if (tbox.z > bbox.z)
      bbox.z = tbox.z;
 
    iChildNodeList++;
  }
 
  return bbox;
}
Ogre::Matrix4 SNode::GetTransformationMatrix()
{
  return O3SceneNode->_getFullTransform();
}
 
Ogre::Vector3 SNode::GetPosition()
{
  return O3SceneNode->getPosition();
}
 
void SNode::SetPosition(const Ogre::Vector3& pos)
{
  if (GetParentScene()->GetRootNode() == this)
    return;
 
  //TODO correct this in Ogre
  //Big hack to avoid the camera to be placed at 0 0 0 to prevent a rectangle2D bug
  if (type == SNode::CAMERA_TYPE_ID && pos.x == 0.0 && pos.y == 0.0 && pos.z == 0.0)
  {
    O3SceneNode->setPosition(Ogre::Vector3(0, 0.0, 0.15));
  }
  else
  {
    if (nodeFather && nodeFather->GetNodeType()==SNode::BONE_TYPE_ID)
    {
      if (ogreMovableObject != 0)
      {
        SBone* boneFather = static_cast <SBone*> (nodeFather);
        boneFather->DetachFromBone(this);
        boneFather->GetOgreSceneNodePointer()->setPosition(pos);
        boneFather->AttachToBone(this);
      }
    }
    else
    {
      O3SceneNode->setPosition(pos);
    }
  }
  
  SetDirty(true);
  UpdateNodeBody(false);
}
 
Ogre::Quaternion SNode::GetOrientation()
{
  if (GetNodeType() == SNode::LIGHT_TYPE_ID) // keep old Ogre light orientation
    return O3SceneNode->getOrientation() * Ogre::Quaternion(0.0f, 0.0f, 1.0f, 0.0f);
  else
    return O3SceneNode->getOrientation();
}
 
void SNode::SetOrientation(const Ogre::Quaternion& quat)
{
  if (GetParentScene()->GetRootNode() == this)
    return;
 
  if (nodeFather && nodeFather->GetNodeType()==SNode::BONE_TYPE_ID)
  {
    if (ogreMovableObject != 0)
    {
      SBone* boneFather = static_cast <SBone*> (nodeFather);
      boneFather->DetachFromBone(this);
      boneFather->GetOgreSceneNodePointer()->setOrientation(quat);
      boneFather->AttachToBone(this);
    }
  }
  else if (GetNodeType() == SNode::LIGHT_TYPE_ID) // keep old Ogre light orientation
  {
    O3SceneNode->setOrientation(quat * Ogre::Quaternion(0.0f, 0.0f, 1.0f, 0.0f));
  }
  else
  {
    O3SceneNode->setOrientation(quat);
  }
 
  SetDirty(true);
  UpdateNodeBody(false);
}
 
void SNode::AddOrientation(const Ogre::Quaternion& quat)
{
  Ogre::Quaternion tmpQuat(quat);
  tmpQuat.normalise();
  if (tmpQuat != Ogre::Quaternion::ZERO)
    SetOrientation(GetOrientation() * tmpQuat);
}
 
Ogre::Vector3 SNode::GetScale()
{
  return O3SceneNode->getScale();
}
 
void SNode::SetScale(const Ogre::Vector3& scale)
{
  if (GetParentScene()->GetRootNode() == this)
    return;
 
  Ogre::Vector3 nscale = scale;
  if (fabs(nscale.x) < 0.000001f)
    nscale.x = 0.000001f;
  if (fabs(nscale.y) < 0.000001f)
    nscale.y = 0.00001f;
  if (fabs(nscale.z) < 0.000001f)
    nscale.z = 0.000001f;
 
  O3SceneNode->setScale(nscale);
 
  SetDirty(true);
  UpdateNodeBody(true);
}
 
Ogre::Vector3 SNode::GetGlobalPosition()
{
  if (mIsDirty)
  {
    O3SceneNode->_update(false, true);
    SetDirty(false);
  }
 
  return O3SceneNode->_getDerivedPosition();
}
 
void SNode::SetGlobalPosition(const Ogre::Vector3& pos, bool updateBody)
{
  if (GetParentScene()->GetRootNode() == this)
    return;
 
  if (nodeFather && nodeFather->GetNodeType()==SNode::BONE_TYPE_ID)
  {
    if (ogreMovableObject != 0)
    {
      SBone* boneFather = static_cast <SBone*> (nodeFather);
 
      if (boneFather->IsDirty())
      {
        boneFather->GetParentSceneNode()->GetOgreSceneNodePointer()->_update(false, true);
        boneFather->SetDirty(false);
      }
 
      boneFather->DetachFromBone(this);
      boneFather->GetParentSceneNode()->GetOgreSceneNodePointer()->setPosition(boneFather->GetParentSceneNode()->GetGlobalOrientation().Inverse() * (pos - boneFather->GetParentSceneNode()->GetGlobalPosition() / boneFather->GetParentSceneNode()->GetGlobalScale()));
      boneFather->AttachToBone(this);
    }
  }
  else
  {
    Ogre::Node* m_nodeParent = O3SceneNode->getParent();
    if (m_nodeParent)
    {
      if (nodeFather->IsDirty())
      {
        m_nodeParent->_update(false, true);
        nodeFather->SetDirty(false);
      }
 
      Ogre::Vector3 gscale = m_nodeParent->_getDerivedScale();
      //if this is a bad scale we ignore the set position
      if (gscale.x == 0.0f || gscale.y == 0.0f || gscale.z == 0.0f)
        return;
      O3SceneNode->setPosition((m_nodeParent->_getDerivedOrientation().Inverse() * (pos - m_nodeParent->_getDerivedPosition()) / gscale));
    }
    else
      O3SceneNode->setPosition(pos);
  }
 
  SetDirty(true);
 
  if (updateBody)
    UpdateNodeBody(false);
}
 
Ogre::Quaternion SNode::GetGlobalOrientation()
{
  if (mIsDirty)
  {
    O3SceneNode->_update(false, true);
    SetDirty(false);
  }
 
  if (GetNodeType() == SNode::LIGHT_TYPE_ID) // keep old Ogre light orientation
    return O3SceneNode->_getDerivedOrientation() * Ogre::Quaternion(0.0f, 0.0f, 1.0f, 0.0f);
  else
    return O3SceneNode->_getDerivedOrientation();
}
 
void SNode::SetGlobalOrientation(const Ogre::Quaternion& quat, bool updateBody)
{
  if (GetParentScene()->GetRootNode() == this)
    return;
 
  if (nodeFather && nodeFather->GetNodeType()==SNode::BONE_TYPE_ID)
  {
    if (ogreMovableObject != 0)
    {
      SBone* boneFather = static_cast <SBone*> (nodeFather);
      boneFather->DetachFromBone(this);
 
      if (boneFather->IsDirty())
      {
        boneFather->GetParentSceneNode()->GetOgreSceneNodePointer()->_update(false, true);
        boneFather->SetDirty(false);
      }
 
      boneFather->GetParentSceneNode()->GetOgreSceneNodePointer()->setOrientation(boneFather->GetParentSceneNode()->GetGlobalOrientation().Inverse() * quat);
      boneFather->AttachToBone(this);
    }
  }
  if (GetNodeType() == SNode::LIGHT_TYPE_ID) // keep old Ogre light orientation
  {
    Ogre::Node* m_nodeParent = O3SceneNode->getParent();
    if (m_nodeParent)
    {
      if (nodeFather->IsDirty())
      {
        m_nodeParent->_update(false, true);
        nodeFather->SetDirty(false);
      }
 
      O3SceneNode->setOrientation((m_nodeParent->_getDerivedOrientation()).Inverse() * quat * Ogre::Quaternion(0.0f, 0.0f, 1.0f, 0.0f));
    }
    else
      O3SceneNode->setOrientation(quat * Ogre::Quaternion(0.0f, 0.0f, 1.0f, 0.0f));
  }
  else
  {
    Ogre::Node* m_nodeParent = O3SceneNode->getParent();
    if (m_nodeParent)
    {
      if (nodeFather->IsDirty())
      {
        m_nodeParent->_update(false, true);
        nodeFather->SetDirty(false);
      }
 
      O3SceneNode->setOrientation((m_nodeParent->_getDerivedOrientation()).Inverse() * quat);
    }
    else
      O3SceneNode->setOrientation(quat);
  }
 
  SetDirty(true);
 
  if (updateBody)
    UpdateNodeBody(false);
}
 
Ogre::Vector3 SNode::GetGlobalScale()
{
  if (mIsDirty)
  {
    O3SceneNode->_update(false, true);
    SetDirty(false);
  }
 
  return O3SceneNode->_getDerivedScale();
}
 
void SNode::SetGlobalScale(const Ogre::Vector3& scale, bool updateBody)
{
  if (GetParentScene()->GetRootNode() == this)
    return;
 
  Ogre::Vector3 nscale = scale;
  if (fabs(nscale.x) < 0.000001f)
    nscale.x = 0.000001f;
  if (fabs(nscale.y) < 0.000001f)
    nscale.y = 0.00001f;
  if (fabs(nscale.z) < 0.000001f)
    nscale.z = 0.000001f;
 
  Ogre::Node* m_nodeParent = O3SceneNode->getParent();
  if (m_nodeParent)
  {
    if (nodeFather->IsDirty())
    {
      m_nodeParent->_update(false, true);
      nodeFather->SetDirty(false);
    }
 
    Ogre::Vector3 gscale = m_nodeParent->_getDerivedScale();
    //if this is a bad scale we ignore the set position
    if (gscale.x == 0.0f || gscale.y == 0.0f || gscale.z == 0.0f)
      return;
 
    O3SceneNode->setScale(nscale / gscale);
  }
  else
    O3SceneNode->setScale(nscale);
 
  SetDirty(true);
 
  if (updateBody)
    UpdateNodeBody(true);
}
 
bool SNode::GetShowBoundingBox()
{
  return O3SceneNode->getShowBoundingBox();
}
 
void SNode::SetShowBoundingBox(const bool& showBounding)
{
  O3SceneNode->showBoundingBox(showBounding);
}
 
void SNode::SetAutoTracking(const bool& autoTrack, SNode* targetNode, const Ogre::Vector3& localDirectionVector, const Ogre::Vector3& offset)
{
  autoTrackTargetNode = targetNode;
  if (autoTrackTargetNode != 0)
    O3SceneNode->setAutoTracking(autoTrack, targetNode->GetOgreSceneNodePointer());
  else
    O3SceneNode->setAutoTracking(autoTrack);
}
 
SNode* SNode::GetAutoTrackingTarget()
{
  return autoTrackTargetNode;
}
 
void SNode::Pitch(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
{
  O3SceneNode->pitch(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
  SetDirty(true);
  UpdateNodeBody(false);
}
 
void SNode::Yaw(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
{
  O3SceneNode->yaw(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
  SetDirty(true);
  UpdateNodeBody(false);
}
 
void SNode::Roll(const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
{
  O3SceneNode->roll(Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
  SetDirty(true);
  UpdateNodeBody(false);
}
 
void SNode::Rotate(const Ogre::Vector3& axis, const float& radianAngle, const SNode::NodeTransformSpace& relativeTo)
{
  O3SceneNode->rotate(axis, Ogre::Radian(radianAngle), static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
  SetDirty(true);
  UpdateNodeBody(false);
}
 
void SNode::Translate(const Ogre::Vector3& d, const SNode::NodeTransformSpace& relativeTo)
{
  O3SceneNode->translate(d, static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)));
  SetDirty(true);
  UpdateNodeBody(false);
}
 
void SNode::SetDirection(const Ogre::Vector3& vec, const SNode::NodeTransformSpace& relativeTo, const Ogre::Vector3& localDirectionVector)
{
  O3SceneNode->setDirection(vec, static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)), localDirectionVector);
  SetDirty(true);
  UpdateNodeBody(false);
}
 
Ogre::Vector3 SNode::GetDirection(bool derived, Ogre::Vector3 axis)
{
  if (derived)
    return O3SceneNode->_getDerivedOrientation() * axis;
  else
    return O3SceneNode->getOrientation() * axis;
}
 
void SNode::LookAt(const Ogre::Vector3& targetPoint, const SNode::NodeTransformSpace& relativeTo, const Ogre::Vector3& localDirectionVector)
{
  O3SceneNode->lookAt(targetPoint, static_cast <Ogre::Node::TransformSpace> (static_cast<int>(relativeTo)), localDirectionVector);
  SetDirty(true);
  UpdateNodeBody(false);
}
 
bool SNode::GetVisible()
{
  return mVisible;
 
  //SNode* father = nodeFather;
  //Ogre::StaticGeometry* staticGeom = staticGeometry;
  //while ((father != 0) && (staticGeom == 0))
  //{
  //  staticGeom = father->GetStaticGeometry();
  //  father = father->GetParentSceneNode();
  //}
  //
  //if (staticGeom != 0)
  //  result = staticGeom->isVisible();
  //else if (O3SceneNode->numAttachedObjects() != 0)
        //      result = O3SceneNode->getAttachedObject(0)->isVisible();
  //
  //return result;
}
 
void SNode::SetVisible(const bool& visible, const bool& cascade)
{
  mVisible = visible;
 
  // look for static geometry in parents
  SNode* father = nodeFather;
  Ogre::StaticGeometry* staticGeom = staticGeometry;
  while ((father != 0) && (staticGeom == 0))
  {
    staticGeom = father->GetStaticGeometry();
    father = father->GetParentSceneNode();
  }
 
  staticVisibility = visible;
 
  if (staticGeom != 0)
    staticGeom->setVisible(visible);
  else
    O3SceneNode->setVisible(visible, false);
 
  if (GetNodeType() == SNode::LIGHT_TYPE_ID)
  {
    SLight* light = static_cast<SLight*>(this);
      light->SetVisible(visible);
  }
 
  if (cascade)
  {
    SNodeMap::iterator iChildNodeList = childNodeList.begin();
    while (iChildNodeList != childNodeList.end())
    {
      iChildNodeList->second->SetVisible(visible, cascade);
      iChildNodeList++;
    }
  }
}
 
void SNode::StoreInitialPRS()
{
  initialPosition = O3SceneNode->getPosition();
  initialOrientation = O3SceneNode->getOrientation();
        initialScale = O3SceneNode->getScale();
}
 
void SNode::ResetToInitialPRS()
{
  O3SceneNode->setPosition(initialPosition);
  O3SceneNode->setOrientation(initialOrientation);
  O3SceneNode->setScale(initialScale);
 
  UpdateNodeBody(true);
}
 
void SNode::ResetToInitialPosition()
{
  // TODO: with 1.7?
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Not implemented in Ogre 1.6!", "SNode::ResetToInitialPosition");
}
 
void SNode::ResetToInitialOrientation()
{
  O3SceneNode->resetOrientation();
  SetDirty(true);
}
 
void SNode::ResetToInitialScale()
{
  // TODO: with 1.7?
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Not implemented in Ogre 1.6!", "SNode::ResetToInitialScale");
}
 
void SNode::ResetNode()
{
  if (nodeBody)
    nodeBody->Reset();
  else
  {
    if (type == SNode::ENTITY_TYPE_ID)
    {
      SEntity* curEntity = static_cast<SEntity*>(this);
      SSkeleton* skeleton = curEntity->GetSkeleton();
      if (skeleton)
      {
        SBoneMap rootBoneList = skeleton->GetRootBones();
        SBoneMap::iterator iRootBones = rootBoneList.begin();
        while (iRootBones != rootBoneList.end())
        {
          iRootBones->second->ResetNode();
          iRootBones++;
        }
      }
    }
 
    SNodeMap::iterator iChildNodeList = childNodeList.begin();
    while (iChildNodeList != childNodeList.end())
    {
      iChildNodeList->second->ResetNode();
      iChildNodeList++;
    }
  }
}
 
Ogre::Vector3 SNode::GetInitialPosition()
{
  return O3SceneNode->getInitialPosition();
}
 
Ogre::Quaternion SNode::GetInitialOrientation()
{
  return O3SceneNode->getInitialOrientation();
}
 
Ogre::Vector3 SNode::GetInitialScale()
{
  return O3SceneNode->getInitialScale();
}
 
SNodeAnimation* SNode::CreateNodeAnimation(const std::string& animationName, const float& animationLength)
{
  SNodeAnimation* animation = new SNodeAnimation(GetParentScene(), animationName, this, animationCounter++, animationLength);
  AddAnimation(animation);
  return animation;
}
 
void SNode::DeleteAnimation(SAnim* existingAnimation)
{
  // Verify that anim instance is in handled by this SNode instance.
  assert(existingAnimation != 0);
  if(GetAnimation(existingAnimation->GetName()) != existingAnimation)
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Cannot destroy an animation that is not handled by this node", "SNode::DeleteAnimation");
 
  currentScene->RemoveAnimation(existingAnimation);
  RemoveAnimation(existingAnimation);
  SO3_SAFE_DELETE(existingAnimation);
}
 
size_t SNode::GetNumAnimations()
{
  return animationList.size();
}
 
SAnim* SNode::GetAnimation(const std::string& animationName)
{
  SAnimMap::iterator iAnimationSearched = animationList.find(animationName);
  if (iAnimationSearched != animationList.end())
    return iAnimationSearched->second;
  else
    return 0;
}
 
SAnim* SNode::GetAnimation(const unsigned short& animationIndex)
{
  SAnimIndexMap::iterator iAnimationSearched = animationListByIndex.find(animationIndex);
  if (iAnimationSearched != animationListByIndex.end())
    return iAnimationSearched->second;
  else
    return 0;
}
 
SAnimMap SNode::GetAnimations() const
{
  return animationList;
}
 
bool SNode::IsAnimated()
{
  bool animated = false;
  SAnimMap animList;
 
  if (type == SNode::BONE_TYPE_ID)
  {
    SBone* bone = static_cast<SBone*>(this);
    animList = bone->GetSkeleton()->GetAnimations();
  }
  else
    animList = animationList;
 
  if(animList.size() > 0)
  {
    SAnimMap::const_iterator iAnimList = animList.begin();
    while(iAnimList != animList.end() && !animated)
    {
      SAnim* curAnim = iAnimList->second;
      if (curAnim->GetEnable())
        animated = true;
 
      iAnimList++;
    }
  }
 
  return animated;
}
 
void SNode::AddAnimation(SAnim* existingAnimation)
{
  string animationName = existingAnimation->GetName();
  SAnimMap::iterator iAnimationSearched = animationList.find(animationName);
  if (iAnimationSearched == animationList.end())
  {
    animationList.insert(SAnimMap::value_type(animationName, existingAnimation));
    animationListByIndex.insert(SAnimIndexMap::value_type(existingAnimation->GetIndex(), existingAnimation));
  }
  else
  {
    // Animation already exist in the handled animations list.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add animation named \""+ animationName +"\", an element with the same name already exist!", "SNode::AddAnimation");
  }
 
  //also add in scene animation list for update
  currentScene->AddAnimation(existingAnimation);
}
 
void SNode::RemoveAnimation(SAnim* existingAnimation)
{
  RemoveAnimation(existingAnimation->GetName());
  //GetParentScene()->RemoveAnimation(existingAnimation->GetName());
}
 
void SNode::RemoveAnimation(const std::string& animationName)
{
  SAnimMap::iterator iAnimationSearched = animationList.find(animationName);
  if (iAnimationSearched  != animationList.end())
  {
    SAnim* findedAnimation = iAnimationSearched->second;
    animationList.erase(iAnimationSearched);
 
    // Delete from index map too
    SAnimIndexMap::iterator iAnimationIndexSearched = animationListByIndex.find(findedAnimation->GetIndex());
    animationListByIndex.erase(iAnimationIndexSearched);
  }
  else
  {
    // Animation not found in the handled animations list
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Can not remove Animation named \""+ animationName +"\", element not found!", "SNode::RemoveAnimation");
  }
}
 
Ogre::Vector3 SNode::GetPositionFromNode(SNode* nodeRef)
{
        Ogre::Matrix4 mat;
 
  if (mIsDirty)
  {
    O3SceneNode->_update(true, true);
    SetDirty(false);
  }
 
        mat = nodeRef->GetTransformationMatrix().inverse() * GetTransformationMatrix();
 
        return mat.getTrans();
}
 
Ogre::Quaternion SNode::GetOrientationFromNode(SNode* nodeRef)
{
        Ogre::Matrix4 mat;
 
  if (mIsDirty)
  {
    O3SceneNode->_update(true, true);
    SetDirty(false);
  }
 
        mat = nodeRef->GetTransformationMatrix().inverse() * GetTransformationMatrix();
        return Ogre::Quaternion(mat.linear());
}
 
Ogre::Vector3 SNode::GetScaleFromNode(SNode* nodeRef)
{
  Ogre::Vector3 scaleParent;
        Ogre::Vector3 scaleResult(1.0,1.0,1.0);
 
        scaleParent = nodeRef->GetGlobalScale();
 
        if(scaleParent.x != 0.0 && scaleParent.y != 0.0 && scaleParent.z != 0.0)
         scaleResult = GetGlobalScale() / scaleParent;
 
  return scaleResult;
}
 
void SNode::SetInheritOrientation(const bool& state)
{
  O3SceneNode->setInheritOrientation(state);
}
 
bool SNode::GetInheritOrientation()
{
  return O3SceneNode->getInheritOrientation();
}
 
void SNode::ResetOrientation()
{
  O3SceneNode->resetOrientation();
  SetDirty(true);
}
 
void SNode::DeleteBody()
{
  SO3_SAFE_DELETE(nodeBody);
}
 
SBody* SNode::CreateBoxBody(const Ogre::Vector3& size)
{
  // test if the vector is ok, return if not
  if ((size.x == 0.0f) || (size.y == 0.0f) || (size.z == 0.0f))
    return 0;
 
  SShapeBox* shape = new SShapeBox(GetName() + "body_box", this, size);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateBoxBody(const Ogre::Vector3& size, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the vector is ok, return if not
  if ((size.x == 0.0f) || (size.y == 0.0f) || (size.z == 0.0f))
    return 0;
 
  SShapeBox* shape = new SShapeBox(GetName() + "body_box", this, size, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateConeBody(const Ogre::Real& radius, const Ogre::Real& height)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeCone* shape = new SShapeCone(GetName() + "body_cone", this, radius, height);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateConeBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeCone* shape = new SShapeCone(GetName() + "body_cone", this, radius, height, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateEllipsoidBody(const Ogre::Vector3& size)
{
  // test if the vector is ok, return if not
  if ((size.x == 0.0f) || (size.y == 0.0f) || (size.z == 0.0f))
    return 0;
 
  SShapeEllipsoid* shape = new SShapeEllipsoid(GetName() + "body_ellipsoid", this, size);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateEllipsoidBody(const Ogre::Vector3& size, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the vector is ok, return if not
  if ((size.x == 0.0f) || (size.y == 0.0f) || (size.z == 0.0f))
    return 0;
 
  SShapeEllipsoid* shape = new SShapeEllipsoid(GetName() + "body_ellipsoid", this, size, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateCapsuleBody(const Ogre::Real& radius, const Ogre::Real& height)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeCapsule* shape = new SShapeCapsule(GetName() + "body_capsule", this, radius, height);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateCapsuleBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeCapsule* shape = new SShapeCapsule(GetName() + "body_capsule", this, radius, height, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateCylinderBody(const Ogre::Real& radius, const Ogre::Real& height)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeCylinder* shape = new SShapeCylinder(GetName() + "body_cylinder", this, radius, height);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateCylinderBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeCylinder* shape = new SShapeCylinder(GetName() + "body_cylinder", this, radius, height, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateChamferCylinderBody(const Ogre::Real& radius, const Ogre::Real& height)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeChamferCylinder* shape = new SShapeChamferCylinder(GetName() + "body_chamfercylinder", this, radius, height);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateChamferCylinderBody(const Ogre::Real& radius, const Ogre::Real& height, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the height or radius is ok, return if not
  if ((height == 0.0f) || (radius == 0.0f))
    return 0;
 
  SShapeChamferCylinder* shape = new SShapeChamferCylinder(GetName() + "body_chamfercylinder", this, radius, height, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreatePyramidBody(const Ogre::Vector3& size)
{
  // test if the vector is ok, return if not
  if ((size.x == 0.0f) || (size.y == 0.0f) || (size.z == 0.0f))
    return 0;
 
  SShapePyramid* shape = new SShapePyramid(GetName() + "body_pyramid", this, size);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreatePyramidBody(const Ogre::Vector3& size, const Ogre::Vector3& offset, const Ogre::Quaternion& quat)
{
  // test if the vector is ok, return if not
  if ((size.x == 0.0f) || (size.y == 0.0f) || (size.z == 0.0f))
    return 0;
 
  SShapePyramid* shape = new SShapePyramid(GetName() + "body_pyramid", this, size, offset, quat);
  SBody* body = new SBody(this, shape);
  nodeBody = body;
  StoreInitialPRS();
  body->SetScale(GetGlobalScale());
 
  return nodeBody;
}
 
SBody* SNode::CreateConvexHullBody(const Ogre::Real& tolerance)
{
  if (GetNodeType() == SNode::ENTITY_TYPE_ID)
        {
    //check if the object is a triangle list object
    SEntity* entity = static_cast<SEntity*> (this);
    Ogre::MeshPtr mesh = entity->getOgreEntityPointer()->getMesh();
 
    if (!mesh)
      return 0;
 
    bool isTriangleList = false;
    size_t sub = mesh->getNumSubMeshes();
    for (size_t cs = 0; cs < sub && !isTriangleList; cs++)
    {
      Ogre::SubMesh* sub_mesh = mesh->getSubMesh(cs);
      isTriangleList = (sub_mesh->operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST) ? true : false;
    }
 
    if (!isTriangleList)
      return 0;
 
    // test if the mesh is convex, return if not
    Ogre::Vector3 convexTest = entity->GetBoundingBoxSize();
    if ((convexTest.x == 0.0f) || (convexTest.y == 0.0f) || (convexTest.z == 0.0f))
      return 0;
 
    SShapeConvexHull* shape = 0;
 
    shape = new SShapeConvexHull(GetName() + "body_convex", entity, tolerance);
 
    SBody* body = new SBody(this, shape);
    nodeBody = body;
    StoreInitialPRS();
    body->SetScale(GetGlobalScale());
 
    return nodeBody;
        }
 
  return 0;
}
 
SBody* SNode::CreateConcaveHullBody(const Ogre::Real& tolerance)
{
  if (GetNodeType() == SNode::ENTITY_TYPE_ID)
        {
    //check if the object is a triangle list object
                SEntity* entity = static_cast<SEntity*> (this);
    Ogre::MeshPtr mesh = entity->getOgreEntityPointer()->getMesh();
    
    if (!mesh)
      return 0;
 
    bool isTriangleList = false;
    size_t sub = mesh->getNumSubMeshes();
    for (size_t cs = 0; cs < sub && !isTriangleList; cs++)
    {
      Ogre::SubMesh* sub_mesh = mesh->getSubMesh(cs);
      isTriangleList = (sub_mesh->operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST) ? true : false;
    }
 
    if (!isTriangleList)
      return 0;
 
    // test if the mesh is convex, return if not
    Ogre::Vector3 convexTest = entity->GetBoundingBoxSize();
    if ((convexTest.x == 0.0f) || (convexTest.y == 0.0f) || (convexTest.z == 0.0f))
      return 0;
 
    SShapeConcaveHull* shape = 0;
 
    shape = new SShapeConcaveHull(GetName() + "body_convex", entity, tolerance);
 
    SBody* body = new SBody(this, shape);
    nodeBody = body;
    StoreInitialPRS();
    body->SetScale(GetGlobalScale());
 
    return nodeBody;
        }
 
  return 0;
}
 
SBody* SNode::CreateTreeBody(const bool& optimize)
{
  //check if the object is a triangle list object
  if ((GetNodeType() == SNode::ENTITY_TYPE_ID)/* && (staticGeometry == 0)*/)
        {
    SEntity* entity = static_cast<SEntity*> (this);
    if (!entity->getOgreEntityPointer())
      return 0;
 
    Ogre::MeshPtr mesh = entity->getOgreEntityPointer()->getMesh();
 
    if (!mesh)
      return 0;
 
    bool isTriangleList = false;
    size_t sub = mesh->getNumSubMeshes();
    for (size_t cs = 0; cs < sub && !isTriangleList; cs++)
    {
      Ogre::SubMesh* sub_mesh = mesh->getSubMesh(cs);
      isTriangleList = (sub_mesh->operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST) ? true : false;
    }
 
    if (!isTriangleList)
      return 0;
 
    SShapeTree* shape = new SShapeTree(GetName() + "body_tree", entity, optimize);
    SBody* body = new SBody(this, shape);
    nodeBody = body;
    StoreInitialPRS();
    body->SetScale(GetGlobalScale());
 
    return nodeBody;
        }
  /*
  else if (staticGeometry != 0)
  {
    //TODO
    return 0;
 
    //SShapeTree* shape = new SShapeTree(GetName() + "body_tree", entity, optimize);
    //SBody* body = new SBody(this, shape);
    //nodeBody = body;
    //StoreInitialPRS();
    //body->SetScale(GetGlobalScale());
    //
    //return nodeBody;
  }*/
 
  return 0;
}
 
void SNode::RestoreStaticGraph()
{
  if (nodeFather)
  {
    try
    {
      nodeFather->GetOgreSceneNodePointer()->addChild(O3SceneNode);
    }
    catch(Ogre::Exception &)
    {
      // should not happen
    }
  }
 
  SNodeMap::iterator iChildNodeList = childNodeList.begin();
  while (iChildNodeList != childNodeList.end())
  {
    iChildNodeList->second->RestoreStaticGraph();
    iChildNodeList++;
  }
}
 
void SNode::SetAsStaticGeometry(const bool& state)
{
  if (staticGeometry != 0)
  {
    currentScene->GetOgreScenePointer()->destroyStaticGeometry(GetName());
    staticGeometry = 0;
    RestoreStaticGraph();
 
    O3SceneNode->setVisible(staticVisibility, true);
  }
 
  if (state)
  {
    // look for static geometry mode in fathers node
    SNode* father = nodeFather;
    bool alreadySet = false;
 
    while ((father != 0) && !alreadySet)
    {
      if (father->GetAsStaticGeometry() != 0)
        alreadySet = true;
 
      father = father->GetParentSceneNode();
    }
 
    if (!alreadySet)
    {
      // remove static geometry on sons for sons
      SNodeMap::iterator iChildNodeList = childNodeList.begin();
      while (iChildNodeList != childNodeList.end())
      {
        iChildNodeList->second->SetAsStaticGeometry(false);
        iChildNodeList++;
      }
 
      staticGeometry = currentScene->GetOgreScenePointer()->createStaticGeometry(GetName());
                  staticGeometry->destroy();
                  staticGeometry->addSceneNode(O3SceneNode);
 
      if (GetNodeType() == SNode::ENTITY_TYPE_ID)
            {
                    SEntity* entity = static_cast<SEntity*> (this);
        staticGeometry->setCastShadows(entity->GetCastShadows());
      }
      else
      {
        staticGeometry->setCastShadows(true);
      }
 
                  staticGeometry->build();
      staticGeometry->setVisible(staticVisibility);
 
      O3SceneNode->setVisible(false, true);
 
      if (nodeFather)
        nodeFather->GetOgreSceneNodePointer()->removeChild(O3SceneNode);
    }
  }
}
 
bool SNode::GetAsStaticGeometry()
{
  if (staticGeometry != 0)
    return true;
 
  return false;
}
 
Ogre::StaticGeometry* SNode::GetStaticGeometry()
{
  return staticGeometry;
}
 
bool SNode::IsDirty()
{
  return mIsDirty;
}
 
void SNode::SetDirty(bool state)
{
  mIsDirty = state;
 
  if (state)
  {
    SNodeMap::iterator iChildNodeList = childNodeList.begin();
    while (iChildNodeList != childNodeList.end())
    {
      iChildNodeList->second->SetDirty(state);
      iChildNodeList++;
    }
  }
}
 
void SNode::UpdateNodeFromBody()
{
  if (nodeBody && nodeBody->GetMass() > 0.0f)
    nodeBody->BodyUpdateCallback(nodeBody->getOgreNewtBodyPointer());
  else
  {
    //update body with 0 mass
    if (nodeBody != NULL)
    {
      if (O3SceneNode && type == BONE_TYPE_ID)
      {
        SBone* bone = static_cast<SBone*>(this);
        nodeBody->UpdatePositionOrientation(bone->GetGlobalPosition(), bone->GetGlobalOrientation());
 
        if (IsAnimated())
        {
          nodeBody->SetVelocity(Ogre::Vector3::ZERO);
          nodeBody->SetOmega(Ogre::Vector3::ZERO);
        }
      }
      else
      {
        nodeBody->UpdatePositionOrientation();
      }
    }
 
    if (type == SNode::ENTITY_TYPE_ID)
    {
      SEntity* curEntity = static_cast<SEntity*>(this);
      SSkeleton* skeleton = curEntity->GetSkeleton();
      if (skeleton)
      {
        SBoneMap rootBoneList = skeleton->GetRootBones();
        SBoneMap::iterator iRootBones = rootBoneList.begin();
        while (iRootBones != rootBoneList.end())
        {
          iRootBones->second->UpdateNodeFromBody();
          iRootBones++;
        }
      }
    }
 
    SNodeMap::iterator iChildNodeList = childNodeList.begin();
    while (iChildNodeList != childNodeList.end())
    {
      iChildNodeList->second->UpdateNodeFromBody();
      iChildNodeList++;
    }
  }
}
 
void SNode::SetPhysicsOverride(bool state)
{
  mPhysicsOverride = state;
}
 
 
bool SNode::GetPhysicsOverride()
{
  return mPhysicsOverride;
}
 
}