SO3Scene.cpp

Go to the documentation of this file.

 
#include "SCOLPack/SO3SCOL.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Physics.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3Animation/SO3Anim.h"
#include "SO3Animation/SO3SequenceAnimation.h"
#include "SO3Material/SO3Compositor.h"
#include "SO3Material/SO3Material.h"
#include "SO3Material/SO3Texture.h"
#include "SO3Material/SO3DynamicCubeMap.h"
#include "SO3Material/SO3RenderToTexture.h"
#include "SO3Material/SO3DynamicReflectionMap.h"
#include "SO3Material/SO3ResourceLoader.h"
#include "SO3PhysicGraph/SO3Body.h"
#include "SO3PhysicGraph/SO3MaterialPair.h"
#include "SO3PhysicGraph/SO3MaterialID.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Bone.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3SceneGraph/SO3Light.h"
#include "SO3SceneGraph/SO3NodeScol.h"
#include "SO3SceneGraph/SO3ParticleSystem.h"
#include "SO3SceneGraph/SO3Skeleton.h"
#include "SO3SceneGraph/SO3Environment.h"
#include "SO3SceneGraph/SO3LineEntity.h"
#include "SO3SceneGraph/SO3VirtualPointer.h"
#include "SO3Renderer/SO3LightingManager.h"
#include "SO3SceneGraph/SO3Sun.h"
#include "SO3SceneGraph/SO3Moon.h"
#include "SO3SceneGraph/SO3Terrain.h"
#include "SO3Utils/SO3Exception.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "OgreFontManager.h"
#include "OgreFont.h"
#include <OgreOctreePlugin.h>           
 
#include <boost/numeric/conversion/cast.hpp>
 
extern int SCENE_PRE_RENDER_EVENT;
extern int SCENE_PRE_RENDER_EVENT2;
extern int SCENE_POST_RENDER_EVENT;
extern int SCENE_PRE_RENDER_PHYSIC_EVENT;
extern int ANIMATION_END_EVENT;
 
extern int getScenePreRenderEvent(struct Mmachine*, SCOL_PTR_TYPE, SCOL_PTR_TYPE);
extern int getScenePreRenderEvent2(struct Mmachine*, SCOL_PTR_TYPE, SCOL_PTR_TYPE);
extern int getScenePreRenderPhysicEvent(struct Mmachine*, SCOL_PTR_TYPE, SCOL_PTR_TYPE);
extern int getScenePostRenderEvent(struct Mmachine*, SCOL_PTR_TYPE, SCOL_PTR_TYPE);
 
extern int SO3_BODY_LEAVE_WORLD_MSG;
extern SMaterialPair* getMaterialPairByWorld(SPhysicWorld* world, int ID1, int ID2);
 
namespace SO3
{
 
SScene::SScene(SRoot* parent, const std::string& sceneName) : SData(sceneName)
{
  scolRoot = parent;
  O3SceneManager = Ogre::Root::getSingleton().createSceneManager("OctreeSceneManager", sceneName);
 
  //TODO resize scene octree for raycast if the raycast fail on far distances
  //maybe this will not be needed if the we use rendered depth value in view to get the raycast position
  //what if we resize the octree when we add a mesh using it's position and boundingbox ?
  //bool showOctreeDebug = true;
  //O3SceneManager->setOption("ShowOctree", &showOctreeDebug);
 
  //Ogre::AxisAlignedBox octreeBox(-1000, -1000, -1000, 1000, 1000, 1000);
  //O3SceneManager->setOption("Size", &octreeBox);
 
  //int octreeDepth = 16;
  //O3SceneManager->setOption("Depth", &octreeDepth);
 
  //O3SceneManager->setLateMaterialResolving(false);
  //O3SceneManager->_suppressShadows(true);
 
  Ogre::RenderQueue* rq = O3SceneManager->getRenderQueue();
  //rq->getQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_1)->setShadowsEnabled(false);
  //rq->getQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2)->setShadowsEnabled(false);
  //rq->getQueueGroup(Ogre::RENDER_QUEUE_MAIN)->setShadowsEnabled(false);
  //rq->getQueueGroup(49)->setShadowsEnabled(false);
 
  cAmbientLight = O3SceneManager->getAmbientLight();
  animationCounter = 0;
 
        skyBoxMat.reset();
        skyDomeMat.reset();
        skyPlaneMat.reset();
        hasSkyBox = false;
        skyBoxDrawFirst = false;
        hasSkyDome = false;
        skyDomeDrawFirst = false;
        hasSkyPlane = false;
        skyPlaneDrawFirst = false;
  materialCaster.reset();
  materialReceiver.reset();
  mPreTimer.reset();
  mPostTimer.reset();
  mLastShadowType = SShadowManager::SO3_SHADOWS_NONE;
 
  O3MeshManager = Ogre::MeshManager::getSingletonPtr();
        O3MaterialManager = Ogre::MaterialManager::getSingletonPtr();
        O3TextureManager = Ogre::TextureManager::getSingletonPtr();
        O3SkeletonManager = Ogre::SkeletonManager::getSingletonPtr();
 
  //used for simple ray cast
  mRayQuery = O3SceneManager->createRayQuery(Ogre::Ray(), Ogre::SceneManager::ENTITY_TYPE_MASK);
  mRayQuery->setSortByDistance(true);
 
  SO3DebugOverlay = 0;
  SO3DebugPanel = 0;
  SO3DebugTextArea = 0;
 
  // add default resource group
  std::string groupResource = name + Ogre::RGN_DEFAULT;
  try
  {
    Ogre::ResourceGroupManager::getSingleton().createResourceGroup(groupResource, false);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "SScene: An exception has occurred: %s\n", e.what());
  }
 
  //only on first scene (overlay are common for all scenes and viewports... beurk)
#if !defined(ANDROID) && !defined(RPI) && !defined(__APPLE__)
  try
  {
    if (parent->GetSceneList().size() == 0)
    {
      // init debug overlay
      SO3DebugFont.reset();
      SO3DebugFont = Ogre::FontManager::getSingleton().create(sceneName + "_SO3DebugFont", SO3_INTERNAL_RESOURCE_GROUP );
      SO3DebugFont->setParameter("type", "truetype");
      SO3DebugFont->setParameter("source", "bluehigh.ttf");
      SO3DebugFont->setParameter("size", "16");
      SO3DebugFont->setParameter("resolution", "96");
      //SO3DebugFont->setParameter("code_points", "33-126");
      SO3DebugFont->load();
 
      SO3DebugOverlay = Ogre::OverlayManager::getSingleton().create(sceneName + "_SO3DebugOverlayName");
      SO3DebugPanel = static_cast<Ogre::OverlayContainer*>(Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", sceneName + "_SO3DebugPanelName"));
      SO3DebugTextArea = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton().createOverlayElement("TextArea", sceneName + "_SO3DebugTextAreaName"));
      SO3DebugTextArea->setFontName(SO3DebugFont->getName());
      SO3DebugOverlay->add2D(SO3DebugPanel);
      SO3DebugPanel->addChild(SO3DebugTextArea);
    }
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "CreateScene Error : %s\n", e.getDescription().c_str());
  }
#endif
 
  physicWorld = new SPhysicWorld(this);
 
  // Creating root scene node. Do not add it to node list, to avoid it to be deleted while clearing the scene.
  rootNode = new SNode(this, O3SceneManager->getRootSceneNode()->getName(), true);
 
  // Creating the environment instance
  environment = new SEnvironment(this, sceneName);
 
  //TODO get all viewports and call RegisterViewport()
 
  // Creating Lighting manager.
  lightingManager = new SLightingManager(this);
 
  //RTSS
  //const Ogre::RenderSystemCapabilities* caps = O3Render->getCapabilities();
  //if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
  Ogre::RTShader::ShaderGenerator::getSingletonPtr()->addSceneManager(O3SceneManager);
}
 
SScene::SScene() : SData("")
{
  // Forbiden (private).
}
 
void SScene::clearOgreScene()
{
  if (lightingManager != 0)
    lightingManager->Reset();
  
  mLastShadowType = SShadowManager::SO3_SHADOWS_NONE;
 
  // clear all windows ray cast result to avoid bad pointer reference
  const SWindowMap windowListCopy = GetParent()->GetRenderWindowList();
  SWindowMap::const_iterator iWindowList = windowListCopy.begin();
  while (iWindowList != windowListCopy.end())
  {
    iWindowList->second->InvalidateRayCast();
    iWindowList++;
  }
 
  // ! Ogre Compositor Destruction
        // Destroy all Compositors not protected by /Core /BaseWhite /Stereo
        /*
  TODO JEFF
  Ogre::ResourceManager::ResourceMapIterator itC = Ogre::CompositorManager::getSingleton().getResourceIterator();
        while(itC.hasMoreElements())
        {
                SCompositor* currentCompositor = NULL;
                Ogre::CompositorPtr cmp = static_cast<Ogre::CompositorPtr>(itC.getNext());
                GetCompositorByName(this,&currentCompositor,cmp->getName().c_str());
                if(currentCompositor)
                {
                        if(currentCompositor->getOgreCompositorViewport()!= NULL)
                        {
                                this->O3CompositorManager->setCompositorEnabled(currentCompositor->getOgreCompositorViewport(), cmp->getName().c_str(), false);
                                if((cmp->getName().find("Ogre/") == string::npos) && (cmp->getName().find("Core/") == string::npos) && (cmp->getName().find("Stereo/") == string::npos))
                                        this->O3CompositorManager->removeCompositor(currentCompositor->getOgreCompositorViewport(),cmp->getName().c_str());
                        }
                }
        }*/
 
  // Do this before everithing else, cause this component handles Ogre::Light and other stuff that belongs to the scene, which can be destroy in the lines below.
  SO3_SAFE_DELETE(environment);
 
  // Delete all SNode and inherited objects. SBody, SAnimation, etc associated to any SNode are destroyed too.
  DeleteAllNodes();
 
  // Delete terrains
  DeleteAllTerrains();
 
  // Clear physic material pair callback
  if(physicWorld)
    physicWorld->ResetPhysicWorld();
 
  // Clear sequence animations
  DeleteAllAnimations();
 
  // ! OgreNewton disable
  if(physicWorld)
    physicWorld->SetPhysicWorldEnable(false);
 
        O3SceneManager->destroyAllBillboardChains();
        O3SceneManager->destroyAllBillboardSets();
  O3SceneManager->destroyAllRibbonTrails();
 
  O3SkeletonManager->unloadAll(false);
  O3SkeletonManager->removeAll();
 
  // ! Skies Destruction
        //O3SceneManager->destroyAllInstancedGeometry();
 
  Ogre::SceneManager::MovableObjectMap movableList = O3SceneManager->getMovableObjects("ManualObject");
  for (Ogre::SceneManager::MovableObjectMap::iterator itMO = movableList.begin(); itMO != movableList.end(); itMO++)
  {
    Ogre::ManualObject* curObj = static_cast<Ogre::ManualObject *>(itMO->second);
                if(strcmp(curObj->getName().c_str(),"SkyBox"))
      O3SceneManager->destroyManualObject(curObj->getName());
        }
 
        this->O3SceneManager->destroyAllStaticGeometry();
 
        if(hasSkyBox)
                O3SceneManager->setSkyBox(false, skyBoxMat->getName());
 
        if(this->hasSkyDome)
                O3SceneManager->setSkyDome(false, skyDomeMat->getName());
 
        if(this->hasSkyPlane)
                O3SceneManager->setSkyPlane(false, skyPlane, skyPlaneMat->getName());
 
  // Delete all materials
  DeleteAllMaterials();
 
  // Delete all textures
  DeleteAllTextures();
 
  // ! Clear Ogre Scene
        O3SceneManager->clearScene();
 
  //reset octree settings
  //bool showOctreeDebug = true;
  //O3SceneManager->setOption("ShowOctree", &showOctreeDebug);
 
  //Ogre::AxisAlignedBox octreeBox(-1000, -1000, -1000, 1000, 1000, 1000);
  //O3SceneManager->setOption("Size", &octreeBox);
 
  //int octreeDepth = 16;
  //O3SceneManager->setOption("Depth", &octreeDepth);
 
  //const Ogre::RenderSystemCapabilities* caps = SRoot::getSingletonPtr()->GetOgreRenderSystem()->getCapabilities();
  //if (caps && caps->hasCapability(Ogre::RSC_FIXED_FUNCTION) == false)
    Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeAllShaderBasedTechniques();
 
  // Reset fog setting
  O3SceneManager->setFog(Ogre::FOG_NONE, Ogre::ColourValue::White, 0, 0, 0);
 
  // Everything was resetted, we can re-create our environment.
  environment = new SEnvironment(this, name);
}
 
SScene::~SScene()
{
  if (SO3DebugOverlay)
  {
    Ogre::OverlayManager::getSingleton().destroyOverlayElement(static_cast<Ogre::OverlayElement*>(SO3DebugPanel));
    Ogre::OverlayManager::getSingleton().destroyOverlayElement(static_cast<Ogre::OverlayElement*>(SO3DebugTextArea));
    Ogre::OverlayManager::getSingleton().destroy(SO3DebugOverlay);
    SO3DebugPanel = 0;
    SO3DebugTextArea = 0;
    SO3DebugOverlay = 0;
  }
 
  if (mRayQuery)
  {
    O3SceneManager->destroyQuery(mRayQuery);
    mRayQuery = 0;
  }
 
  // Unload debug font
  if (SO3DebugFont)
  {
    Ogre::FontManager::getSingleton().remove(SO3DebugFont);
    SO3DebugFont.reset();
  }
 
  if (lightingManager != 0)
    lightingManager->Reset();
 
  // clear all windows ray cast result to avoid bad pointer reference
  const SWindowMap windowListCopy = GetParent()->GetRenderWindowList();
  SWindowMap::const_iterator iWindowList = windowListCopy.begin();
  while (iWindowList != windowListCopy.end())
  {
    iWindowList->second->InvalidateRayCast();
    iWindowList++;
  }
 
  // Do this before everithing else, cause this component handles Ogre::Light and other stuff that belongs to the scene, which can be destroy in the lines below.
  SO3_SAFE_DELETE(environment);
 
  // Delete all SNode and inherited objects. SBody, SAnimation, etc associated to any SNode are destroyed too.
  DeleteAllNodes();
 
  // Delete terrains
  DeleteAllTerrains();
 
  // Clear physic material pair callback
  if(physicWorld)
    physicWorld->ResetPhysicWorld();
 
  // Clear sequence animations
  DeleteAllAnimations();
 
  // ! OgreNewton disable
  if(physicWorld)
    physicWorld->SetPhysicWorldEnable(false);
  
  //$BB Why Snode not enought ?
        O3SceneManager->destroyAllBillboardChains();
        O3SceneManager->destroyAllBillboardSets();  
  O3SceneManager->destroyAllRibbonTrails();
 
  O3SkeletonManager->unloadAll(false);
  O3SkeletonManager->removeAll();
 
  // ! Skies Destruction
        //O3SceneManager->destroyAllInstancedGeometry();
 
  Ogre::SceneManager::MovableObjectMap movableList = O3SceneManager->getMovableObjects("ManualObject");
  for (Ogre::SceneManager::MovableObjectMap::iterator itMO = movableList.begin(); itMO != movableList.end(); itMO++)
  {
    Ogre::ManualObject* curObj = static_cast<Ogre::ManualObject *>(itMO->second);
    if (strcmp(curObj->getName().c_str(), "SkyBox"))
      O3SceneManager->destroyManualObject(curObj->getName());
  }
 
        this->O3SceneManager->destroyAllStaticGeometry();
 
  // Delete all materials
  DeleteAllMaterials();
 
  // Delete all textures
  DeleteAllTextures();
 
  SO3_SAFE_DELETE(lightingManager);
  SO3_SAFE_DELETE(rootNode);
 
        nodeList.clear();
        listOfMaterial.clear();
        listOfTexture.clear();
 
  // ! Clear Ogre Scene
        O3SceneManager->clearScene();
 
  Ogre::RTShader::ShaderGenerator::getSingletonPtr()->removeSceneManager(O3SceneManager);
 
  Ogre::Root::getSingleton().destroySceneManager(O3SceneManager);
        SAFE_DELETE(physicWorld);
 
  std::string groupResource(GetName() + Ogre::RGN_DEFAULT);
  Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup(groupResource);
}
 
bool SScene::NodeExist(const std::string &name)
{
  SNodeMap::iterator iNodeSearched = nodeList.find(name);
  if (iNodeSearched == nodeList.end())
    return false;
  else
    return true;
}
 
bool SScene::AddNode(SNode* existingNode)
{
  string nodeName = existingNode->GetName();
  SNodeMap::iterator iNodeSearched = nodeList.find(nodeName);
  if (iNodeSearched == nodeList.end())
  {
    nodeList.insert(SNodeMap::value_type(nodeName, existingNode));
    return true;
  }
  else
  {
    return false;
  }
}
 
void SScene::RemoveNode(SNode* existingNode)
{
  RemoveNode(existingNode->GetName());
}
 
void SScene::RemoveNode(const std::string& nodeName)
{
  SNodeMap::iterator iNodeSearched = nodeList.find(nodeName);
  if (iNodeSearched != nodeList.end())
  {
    nodeList.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!", "SScene::RemoveNode");
  }
}
 
Ogre::SceneManager* SScene::GetOgreScenePointer()
{
  return O3SceneManager;
}
 
SNode* SScene::GetRootNode()
{
  return rootNode;
}
 
SNode* SScene::GetNode(const std::string& nodeName) const
{
  SNodeMap::const_iterator iNodeSearched = nodeList.find(nodeName);
  if (iNodeSearched != nodeList.end())
    return iNodeSearched->second;
  else
    return 0;
}
 
void SScene::PreUpdate()
{
  if (SRoot::getSingletonPtr()->isDeviceLost())
    return;
 
  unsigned long frameTime = mPreTimer.getMicroseconds();
  mPreTimer.reset();
 
  float timef = (float)frameTime * 0.000001;
  if (timef == 0.0f)
    timef = 0.000001f;
 
  int mframetime = 0;
  try
  {
    mframetime = boost::numeric_cast<int>(frameTime);
  }
  catch (std::exception&)
  {
    mframetime = 100;
  }
 
  getScenePreRenderEvent(mm, SCOL_PTR this, (LONG)mframetime);
 
  //update animations and bodies for node animation sync
  Ogre::FrameEvent evt;
  evt.timeSinceLastFrame = timef;
  evt.timeSinceLastEvent = timef;
 
  //UpdateAllTerrains();
 
  //update sequence animations
  SAnimMap seqAnimList = animationList;
  SAnimMap::const_iterator iSeqAnimList = seqAnimList.begin();
 
  //two pass one for anim sequence the other for nodes
  while(iSeqAnimList != seqAnimList.end())
  {
    SAnim* curAnim = iSeqAnimList->second;
    if (curAnim->GetType() == SAnim::SO3_SEQUENCE_ANIM)
      curAnim->Update(evt);
 
    iSeqAnimList++;
  }
 
  iSeqAnimList = seqAnimList.begin();
  while(iSeqAnimList != seqAnimList.end())
  {
    SAnim* curAnim = iSeqAnimList->second;
    SNode* curNode = curAnim->GetParentNode();
 
    if ((curAnim->GetType() != SAnim::SO3_SEQUENCE_ANIM) && curAnim->GetEnable() && !curAnim->GetPaused())
    {
      curAnim->Update(evt);
 
      //force animations Update
      //code from ogre _renderScene, this duplicate the animation update but we do not change the animation frame in the scene manager
      O3SceneManager->_applySceneAnimations();
 
      if(curNode && physicWorld && physicWorld->GetPhysicWorldEnable())
      {
              curNode->UpdateNodeBody(true);
 
        // not needed anymore
        /*if (curNode->GetNodeType() == SNode::ENTITY_TYPE_ID && curAnim->GetType() == SAnim::SO3_SKELETAL_ANIM)
        {
          SEntity* curEntity = static_cast<SEntity*> (curNode);
          SSkeleton* skeleton = curEntity->GetSkeleton();
          if (skeleton)
          {
            SBoneMap boneList = skeleton->GetBones();
            SBoneMap::const_iterator iBones = boneList.begin();
            while (iBones != boneList.end());
            {
              iBones->second->UpdateNodeBody(false);
            }
          }
        }*/
      }
    }
 
    iSeqAnimList++;
  }
 
  getScenePreRenderPhysicEvent(mm, SCOL_PTR this, (LONG)mframetime);
 
  if(physicWorld)
    physicWorld->UpdatePhysic(timef);
 
  // raycast are enable even if physics is disable
  if (physicWorld && physicWorld->GetPhysicDebugger())
    physicWorld->GetPhysicDebugger()->clearRaycastsRecorded();
 
  getScenePreRenderEvent2(mm, SCOL_PTR this, (LONG)mframetime);
}
 
void SScene::PostUpdate()
{
  if (SRoot::getSingletonPtr()->isDeviceLost())
    return;
 
  int mframetime = 0;
  try
  {
    mframetime = boost::numeric_cast<int>(mPostTimer.getMicroseconds());
  }
  catch (std::exception&)
  {
    mframetime = 100;
  }
 
  if (mframetime == 0)
    mframetime = 1;
  mPostTimer.reset();
 
  getScenePostRenderEvent(mm, SCOL_PTR this, (LONG)mframetime);
 
  //SendMessage(hwndScol, SCENE_POST_RENDER_EVENT, (int)this, (LONG)frameTime);
}
 
const SNodeMap& SScene::GetNodeList() const
{
  return nodeList;
}
 
 
const STerrainMap& SScene::GetTerrainList() const
{
  return terrainList;
}
 
SNode* SScene::CreateNode(const std::string& newNodeName)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newNodeName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newNodeName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SNode* newNode = new SNode(this, newNodeName);
  AddNode(newNode);
 
  return newNode;
}
 
SNode* SScene::CreateNodeWithUniqueName(const std::string& basename)
{
  size_t ID = nodeList.size();
 
  std::stringstream ss;
  ss << basename;
  ss << ID;
  string name = ss.str();
 
  // Node already exist in the handled nodes list.
  if (NodeExist(name))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + name + "\", an element with the same name already exist!", "SScene::CreateNode", true);
  
  SNode* newNode = new SNode(this, name);
  AddNode(newNode);
 
  return newNode;
}
 
void SScene::DeleteNode(SNode* existingNode)
{
  if (existingNode != rootNode)
  {
    RemoveNode(existingNode);
    SO3_SAFE_DELETE(existingNode);
  }
}
 
SVirtualPointer* SScene::CreateVirtualPointer(const std::string& basename)
{
  SVirtualPointer* newVirtualPointer = new SVirtualPointer(this, basename);
 
  if (!AddNode(newVirtualPointer))
  {
    SAFE_DELETE(newVirtualPointer);
    // Node already exist in the handled nodes list.
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + basename + "\", an element with the same name already exist!", "SScene::CreateVirtualPointer", true);
  }
 
  return newVirtualPointer;
}
 
SCamera* SScene::CreateCamera(const std::string& newCameraName)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newCameraName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newCameraName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SCamera* newCamera = new SCamera(this, newCameraName);
  AddNode(newCamera);
 
  return newCamera;
}
 
SEntity* SScene::CreateEntity(const std::string& groupName, const std::string& newEntityName, const std::string& meshName, bool loadInBackground)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, meshName, loadInBackground);
  AddNode(newEntity);
 
  return newEntity;
}
 
SEntity* SScene::CreateEntity(const std::string& newEntityName, const SEntity::EntityPrefabType& prefabType)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, newEntityName, prefabType);
  AddNode(newEntity);
 
  return newEntity;
}
 
SEntity* SScene::CreateEntity(const std::string& entityName, const std::string& ressourceGroup, Ogre::MeshPtr meshPointer)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(entityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + entityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, entityName, ressourceGroup, meshPointer);
  AddNode(newEntity);
 
  return newEntity;
}
 
SEntity* SScene::CloneEntity(const std::string& newEntityName, SEntity* entity)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, newEntityName, entity->GetGroupName(), entity->getOgreEntityPointer()->getMesh());
  AddNode(newEntity);
 
  //Apply source entity parameters
  newEntity->AttachToParent(entity->GetParentSceneNode());
  newEntity->SetScale(entity->GetScale());
  newEntity->SetPosition(entity->GetPosition());
  newEntity->SetOrientation(entity->GetOrientation());
  newEntity->SetCastShadows(entity->GetCastShadows());
  newEntity->SetFlags(entity->GetFlags());
  newEntity->SetRenderingDistance(entity->GetRenderingDistance());
  newEntity->SetSceneNodeIsMouseClick(entity->GetSceneNodeIsMouseClick());
  newEntity->SetSceneNodeIsMouseForeground(entity->GetSceneNodeIsMouseForeground());
  newEntity->SetSceneNodeMouseFlags(entity->GetSceneNodeMouseFlags());
  newEntity->SetVisibilityFlags(entity->GetVisibilityFlags());
  newEntity->SetVisible(entity->GetVisible());
 
  return newEntity;
}
 
SEntity* SScene::CreatePlane(const std::string& groupName, const std::string& newEntityName, const SPointFloat& sizev, const SPointInt& seg, const SPointFloat& uv)
{
  // check for valid group name
  if(!checkGroupExists(groupName))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \""+ groupName +"\" found, plane creation aborted!", "SScene::CreatePlane", true);
 
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, sizev, seg, uv);
  AddNode(newEntity);
 
  return newEntity;
}
 
SEntity* SScene::CreateSphere(const std::string& groupName, const std::string& newEntityName, const float& radius, const int& rings, const int& segments)
{
  // check for valid group name
  if (!checkGroupExists(groupName))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \"" + groupName + "\" found, sphere creation aborted!", "SScene::CreateSphere", true);
 
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, radius, rings, segments);
  AddNode(newEntity);
 
  return newEntity;
}
 
SEntity* SScene::CreateCone(const std::string& groupName, const std::string& newEntityName, const float& radius, const float& height, const int& segments)
{
  // check for valid group name
  if (!checkGroupExists(groupName))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \"" + groupName + "\" found, cone creation aborted!", "SScene::CreateCone", true);
 
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, radius, height, segments);
  AddNode(newEntity);
 
  return newEntity;
}
 
SEntity* SScene::CreateOctahedron(const std::string& groupName, const std::string& newEntityName, const float& base, const float& bottom, const float& dist)
{
  // check for valid group name
  if (!checkGroupExists(groupName))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \"" + groupName + "\" found, cone creation aborted!", "SScene::CreateOctahedron", true);
 
  // Node already exist in the handled nodes list.
  if (NodeExist(newEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, base, bottom, dist);
  AddNode(newEntity);
 
  return newEntity;
}
 
void SScene::DeleteEntity(SEntity* existingEntity)
{
  DeleteNode(existingEntity);
}
 
void SScene::ReloadEntities()
{
  SNodeMap::iterator iNodeit = nodeList.begin();
  while (iNodeit != nodeList.end())
  {
    SNode* tnode = iNodeit->second;
    if (tnode->GetNodeType() == SNode::ENTITY_TYPE_ID)
      static_cast<SEntity*> (tnode)->Reload();
 
    iNodeit++;
  }
}
 
SLineEntity* SScene::CreateLineEntity(const std::string& newLineEntityName, bool dashed, bool disableDepth)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newLineEntityName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newLineEntityName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SLineEntity* newLineEntity = new SLineEntity(this, newLineEntityName, dashed, disableDepth);
  AddNode(newLineEntity);
 
  return newLineEntity;
}
 
void SScene::DeleteLineEntity(SLineEntity* existingLineEntity)
{
  DeleteNode(existingLineEntity);
}
 
STerrain* SScene::CreateTerrain(const std::string& name)
{
  STerrain* terrain = new STerrain(this, name);
  terrainList.insert(STerrainMap::value_type(name, terrain));
 
  return terrain;
}
 
void SScene::DeleteTerrain(STerrain* terrain)
{
  STerrainMap::iterator iTerrainSearched = terrainList.find(terrain->GetName());
  if (iTerrainSearched != terrainList.end())
  {
    terrainList.erase(iTerrainSearched);
  }
  SAFE_DELETE(terrain);
}
 
void SScene::UpdateAllTerrains()
{
  Ogre::Vector3 sunDir(0.5f, 0.5f, 1.0f);
  Ogre::ColourValue sunColor;
  Ogre::ColourValue ambColor = O3SceneManager->getAmbientLight();
  if (environment)
  {
    SSun* sun = environment->GetSun();
    if(sun)
    {
      sunColor = sun->GetOgreLight()->getDiffuseColour();
      sunDir = sun->GetOgreLight()->getDerivedDirection();
    }
    SMoon* moon = environment->GetMoon();
    if(moon)
    {
      moon->UpdateShadowFarDistance(O3SceneManager->getShadowFarDistance());
      moon->UpdateShadowFarClipDistance(O3SceneManager->getShadowDirectionalLightExtrusionDistance());
    }
  }
 
  sunDir.normalise();
 
  STerrainMap::iterator iTerrainit = terrainList.begin();
  while (iTerrainit != terrainList.end())
  {
    STerrain* terrain = iTerrainit->second;
    terrain->UpdateLight(ambColor, sunColor, sunDir);
    iTerrainit++;
  }
}
 
void SScene::DeleteAllTerrains()
{
  // Delete all STerrain
  const STerrainMap terrainListCopy = terrainList;
  STerrainMap::const_iterator iTerrainList = terrainListCopy.begin();
        while (iTerrainList != terrainListCopy.end())
        {
    DeleteTerrain(iTerrainList->second);
    iTerrainList++;
        }
  terrainList.clear();
}
 
void SScene::UpdateLightsShadowParameters()
{
  SNodeMap::iterator iNodeit = nodeList.begin();
  while (iNodeit != nodeList.end())
  {
    SNode* tnode = iNodeit->second;
    if (tnode->GetNodeType() == SNode::LIGHT_TYPE_ID)
    {
      SLight* light = static_cast<SLight*>(tnode);
      light->UpdateShadowFarDistance(O3SceneManager->getShadowFarDistance());
 
      if(light->GetType() == SLight::SO3_DIRECTIONAL_LIGHT)
        light->UpdateShadowFarClipDistance(O3SceneManager->getShadowDirectionalLightExtrusionDistance());
      else
        light->UpdateShadowFarClipDistance(O3SceneManager->getShadowFarDistance());
    }
 
    iNodeit++;
  }
 
  if (environment)
  {
    SSun* sun = environment->GetSun();
    if(sun)
    {
      sun->UpdateShadowFarDistance(O3SceneManager->getShadowFarDistance());
      sun->UpdateShadowFarClipDistance(O3SceneManager->getShadowDirectionalLightExtrusionDistance());
    }
 
    SMoon* moon = environment->GetMoon();
    if(moon)
    {
      moon->UpdateShadowFarDistance(O3SceneManager->getShadowFarDistance());
      moon->UpdateShadowFarClipDistance(O3SceneManager->getShadowDirectionalLightExtrusionDistance());
    }
  }
}
 
SSkeleton* SScene::CreateSkeleton(const std::string& newSkeletonName, SEntity* entity)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newSkeletonName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newSkeletonName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SSkeleton* newSkeleton = new SSkeleton(this, newSkeletonName, entity);
  AddNode(newSkeleton);
 
  // Generate all the bones and animation for this skeleton
  newSkeleton->Initialise();
  return newSkeleton;
}
 
void SScene::DeleteSkeleton(SSkeleton* existingSkeleton)
{
  DeleteNode(existingSkeleton);
}
 
SBone* SScene::CreateBone(const std::string& newBoneName, SSkeleton* skeleton, const unsigned short& id)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newBoneName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newBoneName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SBone* newBone = new SBone(this, newBoneName, skeleton, id);
  AddNode(newBone);
 
  return newBone;
}
 
void SScene::DeleteBone(SBone* existingBone)
{
  DeleteNode(existingBone);
}
 
SParticleSystem* SScene::CreateParticleSystem(const std::string& newParticleSystemName, const std::string& particleSystemTemplate)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newParticleSystemName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newParticleSystemName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SParticleSystem* newParticleSystem = new SParticleSystem(this, newParticleSystemName, particleSystemTemplate);
  AddNode(newParticleSystem);
 
  return newParticleSystem;
}
 
void SScene::DeleteParticleSystem(SParticleSystem* existingParticleSystem)
{
  DeleteNode(existingParticleSystem);
}
 
SLight* SScene::CreateLight(const std::string& newLightName)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newLightName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newLightName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SLight* newLight = new SLight(this, newLightName);
  AddNode(newLight);
 
  return newLight;
}
 
void SScene::DeleteLight(SLight* existingLight)
{
  DeleteNode(existingLight);
}
 
SDynamicCubeMap* SScene::CreateDynamicCubeMap(const std::string& newDynamicCubeMapName)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newDynamicCubeMapName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newDynamicCubeMapName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SDynamicCubeMap* newDynamicCubeMap = new SDynamicCubeMap(this, newDynamicCubeMapName);
  AddNode(newDynamicCubeMap);
 
  return newDynamicCubeMap;
}
 
void SScene::DeleteDynamicCubeMap(SDynamicCubeMap* existingDynamicCubeMap)
{
  DeleteNode(existingDynamicCubeMap);
}
 
SRenderToTexture* SScene::CreateRenderToTexture(const std::string& newRttName, SCamera* povCamera)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newRttName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newRttName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SRenderToTexture* newRenderToTexture = new SRenderToTexture(this, newRttName, povCamera);
  AddNode(newRenderToTexture);
 
  return newRenderToTexture;
}
 
void SScene::DeleteRenderToTexture(SRenderToTexture* existingRenderToTexture)
{
  DeleteNode(existingRenderToTexture);
}
 
SDynamicReflectionMap* SScene::CreateDynamicReflectionMap(SViewPort* viewport, const std::string& newDynamicReflectionMapName)
{
  // Node already exist in the handled nodes list.
  if (NodeExist(newDynamicReflectionMapName))
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add node named \"" + newDynamicReflectionMapName + "\", an element with the same name already exist!", "SScene::CreateNode", true);
 
  SDynamicReflectionMap* newDynamicReflectionMap = new SDynamicReflectionMap(this, viewport, newDynamicReflectionMapName);
  AddNode(newDynamicReflectionMap);
 
  return newDynamicReflectionMap;
}
 
void SScene::DeleteDynamicReflectionMap(SDynamicReflectionMap* existingDynamicReflectionMap)
{
  DeleteNode(existingDynamicReflectionMap);
}
 
SMaterial* SScene::CreateMaterial(const std::string& groupname, const std::string& matname, const bool& loadedFromScript)
{
  // check for valid group name
  if (!checkGroupExists(groupname))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \"" + groupname + "\" found, material creation aborted!", "SScene::CreateMaterial", true);
 
  // search for existing material
  if (GetMaterial(groupname, matname, false))
    SO3_EXCEPT(SExceptionItemIdentity, "A material named \""+ matname +"\" already exist in resource group \""+ groupname +"\", material creation aborted!", "SScene::CreateMaterial", true);
 
  SMaterialMap* materialMap;
  SGroupMaterialMap::iterator iGroupSearched = listOfMaterial.find(groupname);
  if(iGroupSearched != listOfMaterial.end())
  {
    materialMap = iGroupSearched->second;
  }
  else
  {
    materialMap = new SMaterialMap();
    listOfMaterial.insert(SGroupMaterialMap::value_type(groupname, materialMap));
  }
 
  SMaterial* material = new SMaterial(this, groupname, matname, loadedFromScript);
  materialMap->insert(SMaterialMap::value_type(matname, material));
  return material;
}
 
void SScene::DeleteMaterial(SMaterial* material)
{
  // Search for the material group in our scene material group list
  SGroupMaterialMap::const_iterator iGroupSearched = listOfMaterial.find(material->GetGroupName());
  if(iGroupSearched != listOfMaterial.end())
  {
    // Search for the material in the group, and remove from list
    SMaterialMap* materialMap = static_cast<SMaterialMap*> (iGroupSearched->second);
    SMaterialMap::const_iterator iMaterialSearched = materialMap->find(material->GetName());
    if(iMaterialSearched != materialMap->end())
      materialMap->erase(iMaterialSearched);
 
    // If group is empty, then delete if
    if(materialMap->empty())
    {
      listOfMaterial.erase(iGroupSearched);
      delete (materialMap);
    }
 
    // Delete the material instance
    delete(material);
  }
}
 
SMaterial* SScene::GetMaterial(const std::string& groupName, const std::string& materialName, bool searchOtherGroups)
{
  SGroupMaterialMap::const_iterator iGroupSearched = listOfMaterial.find(groupName);
  if(iGroupSearched != listOfMaterial.end())
  {
    SMaterialMap* materialMap = iGroupSearched->second;
    SMaterialMap::iterator iMaterialSearched = materialMap->find(materialName);
    if(iMaterialSearched != materialMap->end())
    {
      return iMaterialSearched->second;
    }
    else if (searchOtherGroups)
    {
      //search other groups
      iGroupSearched = listOfMaterial.begin();
      while (iGroupSearched != listOfMaterial.end())
      {
        materialMap = iGroupSearched->second;
        iMaterialSearched = materialMap->find(materialName);
        if (iMaterialSearched != materialMap->end())
        {
          return iMaterialSearched->second;
        }
 
        iGroupSearched++;
      }
      return 0;
    }    
  }
  else if (searchOtherGroups)
  {
    //search other groups
    iGroupSearched = listOfMaterial.begin();
    while (iGroupSearched != listOfMaterial.end())
    {
      SMaterialMap* materialMap = iGroupSearched->second;
      SMaterialMap::iterator iMaterialSearched = materialMap->find(materialName);
      if (iMaterialSearched != materialMap->end())
      {
        return iMaterialSearched->second;
      }
 
      iGroupSearched++;
    }
  }
  return 0;
}
 
const SMaterialMap* SScene::GetMaterials(const std::string& groupName)
{
  SGroupMaterialMap::const_iterator iGroupSearched = listOfMaterial.find(groupName);
  if(iGroupSearched != listOfMaterial.end())
    return iGroupSearched->second;
  else
    return 0;
}
 
const SGroupMaterialMap* SScene::GetMaterials()
{
  return &listOfMaterial;
}
 
void SScene::CleanGroupMaterials(const std::string& groupName)
{
  // clear all windows ray cast result to avoid bad pointer reference
  const SWindowMap windowListCopy = GetParent()->GetRenderWindowList();
  SWindowMap::const_iterator iWindowList = windowListCopy.begin();
  while (iWindowList != windowListCopy.end())
  {
    iWindowList->second->InvalidateRayCast();
    iWindowList++;
  }
 
  const SGroupMaterialMap groupMaterialListCopy = listOfMaterial;
  SGroupMaterialMap::const_iterator iGroupMaterial = groupMaterialListCopy.find(groupName);
        if (iGroupMaterial != groupMaterialListCopy.end())
        {
    const SMaterialMap materialListCopy = (*iGroupMaterial->second);
    SMaterialMap::const_iterator iMaterial = materialListCopy.begin();
    while(iMaterial != materialListCopy.end())
    {
      DeleteMaterial(iMaterial->second);
      iMaterial++;
          }
  }
}
 
STexture* SScene::CreateTexture(const std::string& groupname, const std::string& texname, const std::string& path, const int& w, const int& h)
{
  // search for existing material
  if (GetTexture (groupname, texname))
    return 0;
 
  // check for valid group name
  if(!checkGroupExists(groupname))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \""+ groupname +"\" found, texture creation aborted!", "SScene::CreateTexture", true);
 
  STextureMap* textureMap;
 
  SGroupTextureMap::iterator iGroupSearched = listOfTexture.find(groupname);
  if(iGroupSearched != listOfTexture.end())
  {
    textureMap = iGroupSearched->second;
  }
  else
  {
    textureMap = new STextureMap();
    listOfTexture.insert(SGroupTextureMap::value_type(groupname, textureMap));
  }
 
  //search if texture exist
  STextureMap::iterator iTextureSearched = textureMap->find(texname);
  if(iTextureSearched != textureMap->end())
    SO3_EXCEPT(SExceptionItemIdentity, "Texture \""+ texname +"\" already exist, texture creation aborted!", "SScene::CreateTexture", true);
 
  STexture* texture = new STexture(this, groupname, texname, path, w, h);
  textureMap->insert(STextureMap::value_type(texname, texture));
  return texture;
}
 
STexture* SScene::CreateTexture(const std::string& groupname, const std::string& texname, Ogre::Image image)
{
  // search for existing material
  if (GetTexture(groupname, texname))
    return 0;
 
  // check for valid group name
  if (!checkGroupExists(groupname))
    SO3_EXCEPT(SExceptionItemIdentity, "No ressource group named \"" + groupname + "\" found, texture creation aborted!", "SScene::CreateTexture", true);
 
  STextureMap* textureMap;
 
  SGroupTextureMap::iterator iGroupSearched = listOfTexture.find(groupname);
  if (iGroupSearched != listOfTexture.end())
  {
    textureMap = iGroupSearched->second;
  }
  else
  {
    textureMap = new STextureMap();
    listOfTexture.insert(SGroupTextureMap::value_type(groupname, textureMap));
  }
 
  //search if texture exist
  STextureMap::iterator iTextureSearched = textureMap->find(texname);
  if (iTextureSearched != textureMap->end())
    SO3_EXCEPT(SExceptionItemIdentity, "Texture \"" + texname + "\" already exist, texture creation aborted!", "SScene::CreateTexture", true);
 
  STexture* texture = new STexture(this, groupname, texname, image);
  textureMap->insert(STextureMap::value_type(texname, texture));
  return texture;
}
 
void SScene::DeleteTexture(STexture* texture)
{
  if(texture)
  {
    SGroupTextureMap::iterator iGroupSearched = listOfTexture.find(texture->GetGroupName());
    if(iGroupSearched != listOfTexture.end())
    {
      STextureMap* textureMap = static_cast<STextureMap*> (iGroupSearched->second);
      STextureMap::iterator iTextureSearched = textureMap->find(texture->GetName());
      if(iTextureSearched != textureMap->end())
        textureMap->erase(iTextureSearched);
 
      if(textureMap->empty())
      {
        listOfTexture.erase(iGroupSearched);
        delete (textureMap);
      }
    }
 
    if (texture->getOgreTexturePointer())
    {
      O3TextureManager->unload(texture->getOgreTexturePointer()->getHandle());
            O3TextureManager->remove(texture->getOgreTexturePointer()->getHandle());
    }
    delete(texture);
  }
}
 
STexture* SScene::GetTexture(const std::string& groupName, const std::string& texName)
{
  SGroupTextureMap::iterator iGroupSearched = listOfTexture.find(groupName);
  if(iGroupSearched != listOfTexture.end())
  {
    STextureMap* textureMap = static_cast<STextureMap*> (iGroupSearched->second);
    STextureMap::iterator iTextureSearched = textureMap->find(texName);
    if(iTextureSearched != textureMap->end())
    {
      return iTextureSearched->second;
    }
    return 0;
  }
  return 0;
}
 
const STextureMap* SScene::GetTextures(const std::string& groupName)
{
  SGroupTextureMap::iterator iGroupSearched = listOfTexture.find(groupName);
  if(iGroupSearched != listOfTexture.end())
    return iGroupSearched->second;
  else
    return 0;
}
 
const SGroupTextureMap* SScene::GetTextures()
{
  return &listOfTexture;
}
 
void SScene::CleanGroupTextures(const std::string& groupName)
{
// First, delete all the scene textures
  const SGroupTextureMap groupTextureListCopy = listOfTexture;
  SGroupTextureMap::const_iterator iGroupTexture = groupTextureListCopy.find(groupName);
        if (iGroupTexture != groupTextureListCopy.end())
        {
    const STextureMap textureListCopy = (*iGroupTexture->second);
    STextureMap::const_iterator iTexture = textureListCopy.begin();
    while(iTexture != textureListCopy.end())
    {
      DeleteTexture(iTexture->second);
      iTexture++;
          }
  }
}
 
SRoot* SScene::GetParent()
{
  return scolRoot;
}
 
SPhysicWorld* SScene::GetPhysicsWorld()
{
  return physicWorld;
}
 
SSequenceAnimation* SScene::CreateAnimationSequence(const std::string& animationName)
{
  SSequenceAnimation* animation = new SSequenceAnimation(this, animationName, animationCounter++);
  AddAnimation(animation);
  return animation;
}
 
void SScene::DeleteAnimation(SAnim* existingAnimation)
{
  // Verify that anim instance is in handled by this SScene 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 scene", "SScene::DeleteAnimation");
 
  RemoveAnimation(existingAnimation);
  SO3_SAFE_DELETE(existingAnimation);
}
 
unsigned short SScene::GetNumAnimations()
{
  return animationList.size();
}
 
SAnim* SScene::GetAnimation(const std::string& animationName)
{
  SAnimMap::iterator iAnimationSearched = animationList.find(animationName);
  if (iAnimationSearched != animationList.end())
    return iAnimationSearched->second;
  else
    return 0;
}
 
SAnimMap SScene::GetAnimations() const
{
  return animationList;
}
 
void SScene::AddAnimation(SAnim* existingAnimation)
{
  string animationName = existingAnimation->GetName();
  if (existingAnimation->GetParentNode())
    animationName = existingAnimation->GetParentNode()->GetName() + animationName;
 
  SAnimMap::iterator iAnimationSearched = animationList.find(animationName);
  if (iAnimationSearched == animationList.end())
  {
    animationList.insert(SAnimMap::value_type(animationName, existingAnimation));
  }
  else
  {
    // Animation already exist in the handled animations list.
    SO3_EXCEPT(SExceptionItemIdentity, "Can not add animation named \""+ animationName +"\", an element with the same name already exist!", "SScene::AddAnimation", true);
  }
}
 
void SScene::RemoveAnimation(SAnim* existingAnimation)
{
  if (existingAnimation->GetParentNode())
    RemoveAnimation(existingAnimation->GetParentNode()->GetName() + existingAnimation->GetName());
  else
    RemoveAnimation(existingAnimation->GetName());
}
 
void SScene::RemoveAnimation(const std::string& animationName)
{
  SAnimMap::iterator iAnimationSearched = animationList.find(animationName);
  if (iAnimationSearched != animationList.end())
  {
    SAnim* findedAnimation = iAnimationSearched->second;
    animationList.erase(iAnimationSearched);
  }
  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!", "SScene::RemoveAnimation");
  }
}
 
SEnvironment* SScene::GetEnvironment() const
{
  return environment;
}
 
SLightingManager* SScene::GetLightingManager()
{
  return lightingManager;
}
 
SShadowManager::ShadowType SScene::GetShadowType()
{
  if (lightingManager != 0)
    return lightingManager->GetShadowManager()->GetShadowType();
  else
    return SShadowManager::SO3_SHADOWS_NONE;
}
 
void SScene::SetShadowType(const SShadowManager::ShadowType& shadowType)
{
  mLastShadowType = shadowType;
  if (lightingManager == 0)
    return;
 
  lightingManager->GetShadowManager()->SetShadowType(shadowType);
}
 
SShadowManager::ShadowQuality SScene::GetShadowQuality()
{
  if (lightingManager != 0)
    return lightingManager->GetShadowManager()->GetShadowQuality();
  else
    return SShadowManager::SO3_SHADOWS_QUALITY_LOW; // default
}
 
void SScene::SetShadowQuality(const SShadowManager::ShadowQuality& quality)
{
  if (lightingManager == 0)
    return;
 
  lightingManager->GetShadowManager()->SetShadowQuality(quality);
}
 
SShadowManager* SScene::GetShadowManager()
{
  if (lightingManager)
    return lightingManager->GetShadowManager();
  else
    return 0;
}
 
void SScene::DestroyInternalRessources()
{
  //if (lightingManager)
    //lightingManager->GetShadowManager()->SetShadowType(SShadowManager::SO3_SHADOWS_NONE);
}
 
void SScene::ReloadInternalRessources()
{
  //if (lightingManager)
    //lightingManager->GetShadowManager()->SetShadowType(mLastShadowType);
}
 
Ogre::ColourValue SScene::GetAmbientLight()
{
  return cAmbientLight;
}
 
void SScene::SetAmbientLight(const Ogre::ColourValue& color)
{
  cAmbientLight = color;
  O3SceneManager->setAmbientLight(color);
}
 
void SScene::UpdateCamera(SViewPort* viewport)
{
  if (environment != 0)
    environment->UpdateCamera(viewport);
}
 
void SScene::RegisterViewport(SViewPort* viewport)
{
  //Let manual register
  //if (environment != 0)
    //environment->RegisterViewport(viewport);
}
 
void SScene::UnregisterViewport(SViewPort* viewport)
{
  if (environment != 0)
    environment->UnregisterViewport(viewport);
}
 
bool SScene::UnloadResource(Ogre::ResourceManager* resMgr, const std::string& resName, const std::string& groupName)
{
  if (!resMgr)
    return false;
 
  Ogre::ResourcePtr rPtr = resMgr->getResourceByName(resName, groupName);
  if (!rPtr)
  {
    // Resource no longer exists
    return true;
  }
 
  rPtr->unload();
  if (rPtr->isLoaded())
  {
    // Resource was not unloaded
    0;
  }
  else
  {
    // Resource was unloaded
    0;
  }
 
  resMgr->remove(resName);
  rPtr = resMgr->getResourceByName(resName, groupName);
  if (!rPtr)
  {
    // Resource was removed
    0;
  }
  else
  {
    // Resource was not removed
    0;
  }
 
  if (resMgr->resourceExists(resName))
  {
    // Resource still exists:
    return false;
    0;
  }
  else
  {
    // Resource no longer exists
    return true;
  }
}
 
bool SScene::UnloadResource(Ogre::ParticleSystemManager* resMgr, const std::string& resName)
{
  if (!resMgr)
    return false;
 
  try
  {
    resMgr->removeTemplate(resName, true);
  }
  catch (Ogre::Exception &)
  {
    // do not exist
    return true;
  }
 
  return true;
}
 
bool SScene::UnloadMaterials(const std::string& filename, const std::string& groupName)
{
  if (filename.empty())
  {
      Ogre::LogManager::getSingleton().logMessage("Filename is empty.");
      return false;
  }
 
  Ogre::DataStreamPtr stream;
  try
  {
    stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename, groupName);
    if (stream)
    {
      while (!stream->eof())
      {
        std::string line = stream->getLine();
        Ogre::StringUtil::trim(line);
 
        if (Ogre::StringUtil::startsWith(line, "material"))
        {
          Ogre::StringVector vec = Ogre::StringUtil::split(line, " \t:");
          bool skipFirst = true;
          for (Ogre::StringVector::iterator it = vec.begin(); it < vec.end(); ++it)
          {
            if (skipFirst)
            {
              skipFirst = false;
              continue;
            }
            std::string match = (*it);
            Ogre::StringUtil::trim(match);
            if (match.front() == '"' && match.back() == '"')
            {
              match.erase(0, 1); // erase the first character
              match.erase(match.size() - 1); // erase the last character
            }
 
            if (!match.empty())
            {
              UnloadResource(Ogre::MaterialManager::getSingletonPtr(), match, groupName);
              break;
            }
          }
        }
      }
    }
    else return false;
  }
  catch (Ogre::Exception &e)
  {
    Ogre::StringStream msg;
    msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
    Ogre::LogManager::getSingleton().logMessage(msg.str());
 
    if (stream)
      stream->close();
    return false;
  }
 
  if (stream)
    stream->close();
  return true;
}
 
bool SScene::UnloadCompositors(const std::string& filename, const std::string& groupName)
{
  if (filename.empty())
  {
      Ogre::LogManager::getSingleton().logMessage("Filename is empty.");
      return false;
  }
 
  Ogre::DataStreamPtr stream;
  try
  {
    stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename, groupName);
    if (stream)
    {
      while (!stream->eof())
      {
        std::string line = stream->getLine();
        Ogre::StringUtil::trim(line);
 
        if (Ogre::StringUtil::startsWith(line, "compositor"))
        {
          Ogre::StringVector vec = Ogre::StringUtil::split(line, " \t:");
          bool skipFirst = true;
          for (Ogre::StringVector::iterator it = vec.begin(); it < vec.end(); ++it)
          {
            if (skipFirst)
            {
              skipFirst = false;
              continue;
            }
            std::string match = (*it);
            Ogre::StringUtil::trim(match);
            if (match.front() == '"' && match.back() == '"')
            {
              match.erase(0, 1); // erase the first character
              match.erase(match.size() - 1); // erase the last character
            }
 
            if (!match.empty())
            {
              UnloadResource(Ogre::CompositorManager::getSingletonPtr(), match, groupName);
              break;
            }
          }
        }
      }
    }
    else return false;
  }
  catch (Ogre::Exception &e)
  {
    Ogre::StringStream msg;
    msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
    Ogre::LogManager::getSingleton().logMessage(msg.str());
 
    if(stream)
      stream->close();
    return false;
  }
 
  if (stream)
    stream->close();
  return true;
}
 
bool SScene::UnloadParticles(const std::string& filename, const std::string& groupName)
{
  if (filename.empty())
  {
      Ogre::LogManager::getSingleton().logMessage("Filename is empty.");
      return false;
  }
 
  Ogre::DataStreamPtr stream;
  try
  {
    stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename, groupName);
    if (stream)
    {
      while (!stream->eof())
      {
        std::string line = stream->getLine();
        Ogre::StringUtil::trim(line);
 
        if (Ogre::StringUtil::startsWith(line, "particle_system"))
        {
          Ogre::StringVector vec = Ogre::StringUtil::split(line, " \t:");
          bool skipFirst = true;
          for (Ogre::StringVector::iterator it = vec.begin(); it < vec.end(); ++it)
          {
            if (skipFirst)
            {
              skipFirst = false;
              continue;
            }
            std::string match = (*it);
            Ogre::StringUtil::trim(match);
            if (match.front() == '"' && match.back() == '"')
            {
              match.erase(0, 1); // erase the first character
              match.erase(match.size() - 1); // erase the last character
            }
 
            if (!match.empty())
            {
              UnloadResource(Ogre::ParticleSystemManager::getSingletonPtr(), match);
              break;
            }
          }
        }
      }
    }
    else return false;
  }
  catch (Ogre::Exception &e)
  {
    Ogre::StringStream msg;
    msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
    Ogre::LogManager::getSingleton().logMessage(msg.str());
    
    if (stream)
      stream->close();
    return false;
  }
 
  if (stream)
    stream->close();
  return true;
}
 
bool SScene::UnloadVertexPrograms(const std::string& filename, const std::string& groupName)
{
  if (filename.empty())
  {
      Ogre::LogManager::getSingleton().logMessage("Filename is empty.");
      return false;
  }
 
  Ogre::DataStreamPtr stream;
  try
  {
    stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename, groupName);
    if (stream)
    {
      while (!stream->eof())
      {
        std::string line = stream->getLine();
        Ogre::StringUtil::trim(line);
 
        if (Ogre::StringUtil::startsWith(line, "vertex_program") && !Ogre::StringUtil::startsWith(line, "vertex_program_ref"))
        {
          Ogre::StringVector vec = Ogre::StringUtil::split(line, " \t:");
          bool skipFirst = true;
          for (Ogre::StringVector::iterator it = vec.begin(); it < vec.end(); ++it)
          {
            if (skipFirst)
            {
              skipFirst = false;
              continue;
            }
            std::string match = (*it);
            Ogre::StringUtil::trim(match);
            if (match.front() == '"' && match.back() == '"')
            {
              match.erase(0, 1); // erase the first character
              match.erase(match.size() - 1); // erase the last character
            }
 
            if (!match.empty())
            {
              UnloadResource(Ogre::GpuProgramManager::getSingletonPtr(), match, groupName);
              break;
            }
          }
        }
      }
    }
    else return false;
  }
  catch (Ogre::Exception &e)
  {
    Ogre::StringStream msg;
    msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
    Ogre::LogManager::getSingleton().logMessage(msg.str());
 
    if (stream)
      stream->close();
    return false;
  }
 
  if (stream)
    stream->close();
  return true;
}
 
bool SScene::UnloadFragmentPrograms(const std::string& filename, const std::string& groupName)
{
  if (filename.empty())
  {
      Ogre::LogManager::getSingleton().logMessage("Filename is empty.");
      return false;
  }
 
  Ogre::DataStreamPtr stream;
  try
  {
    stream = Ogre::ResourceGroupManager::getSingleton().openResource(filename, groupName);
    if (stream)
    {
      while (!stream->eof())
      {
        std::string line = stream->getLine();
        Ogre::StringUtil::trim(line);
 
        if (Ogre::StringUtil::startsWith(line, "fragment_program") && !Ogre::StringUtil::startsWith(line, "fragment_program_ref"))
        {
          Ogre::StringVector vec = Ogre::StringUtil::split(line, " \t:");
          bool skipFirst = true;
          for (Ogre::StringVector::iterator it = vec.begin(); it < vec.end(); ++it)
          {
            if (skipFirst)
            {
              skipFirst = false;
              continue;
            }
            std::string match = (*it);
            Ogre::StringUtil::trim(match);
            if (match.front() == '"' && match.back() == '"')
            {
              match.erase(0, 1); // erase the first character
              match.erase(match.size() - 1); // erase the last character
            }
 
            if (!match.empty())
            {
              UnloadResource(Ogre::GpuProgramManager::getSingletonPtr(), match, groupName);
              break;
            }
          }
        }
      }
    }
    else return false;
  }
  catch (Ogre::Exception &e)
  {
    Ogre::StringStream msg;
    msg << "Exception: FILE: " << __FILE__ << " LINE: " << __LINE__ << " DESC: " << e.getFullDescription() << std::endl;
    Ogre::LogManager::getSingleton().logMessage(msg.str());
 
    if (stream)
      stream->close();
    return false;
  }
 
  if (stream)
    stream->close();
  return true;
}
 
bool SScene::ParseResourceScript(const std::string& groupName, const std::string& scriptName, const SResource::ResourceType& scriptType)
{
  Ogre::DataStreamPtr ds;
  ds.reset();
 
  try
  {
    // unload resource first
    switch(scriptType)
    {
      case SResource::SO3_RESOURCE_MESH:
              //UnloadResource(Ogre::MeshManager::getSingletonPtr(), scriptName, groupName);
        break;
      case SResource::SO3_RESOURCE_MATERIAL:
        UnloadMaterials(scriptName, groupName);
        UnloadVertexPrograms(scriptName, groupName);
              UnloadFragmentPrograms(scriptName, groupName);
        break;
      case SResource::SO3_RESOURCE_COMPOSITOR:
        UnloadCompositors(scriptName, groupName);
        break;
      case SResource::SO3_RESOURCE_PARTICLE_SYSTEM:
        UnloadParticles(scriptName, groupName);
        break;
      case SResource::SO3_RESOURCE_TEXTURE:
        {
          Ogre::TexturePtr tex = Ogre::TextureManager::getSingletonPtr()->getByName(scriptName, groupName);
          if (tex && tex.use_count() == 0)
                  UnloadResource(Ogre::TextureManager::getSingletonPtr(), scriptName, groupName);
        }
        break;
      case SResource::SO3_RESOURCE_SKELETON:
        {
          Ogre::SkeletonPtr skl = Ogre::SkeletonManager::getSingletonPtr()->getByName(scriptName, groupName);
          if (skl && skl.use_count() == 0)
                  UnloadResource(Ogre::SkeletonManager::getSingletonPtr(), scriptName, groupName);
        }
        break;
      case SResource::SO3_RESOURCE_GPUPROGRAM:
        UnloadResource(Ogre::MaterialManager::getSingletonPtr(), scriptName, groupName);
        break;
      case SResource::SO3_RESOURCE_HIGHLEVELGPUPROGRAM:
        UnloadResource(Ogre::GpuProgramManager::getSingletonPtr(), scriptName, groupName);
        break;
    }
 
    // Open data stream
    if ((scriptType != SResource::SO3_RESOURCE_TEXTURE) || (scriptType != SResource::SO3_RESOURCE_MESH))
      ds = Ogre::ResourceGroupManager::getSingleton().openResource(scriptName, groupName);
 
    // Set current scene as target for the resource loader
    SResourceLoader::getSingleton().SetResourceScene(this);
 
    // Parse content
    Ogre::ResourceGroupManager* ogreResourceGroupManager = Ogre::ResourceGroupManager::getSingletonPtr();
 
    switch(scriptType)
    {
      case SResource::SO3_RESOURCE_MESH:
              O3MeshManager->load(scriptName, groupName);
        break;
      case SResource::SO3_RESOURCE_MATERIAL:
              O3MaterialManager->parseScript(ds, groupName);
        SResourceLoader::getSingleton().SyncParsedMaterials();
        break;
      case SResource::SO3_RESOURCE_COMPOSITOR:
        Ogre::CompositorManager::getSingleton().parseScript(ds, groupName);
        break;
      case SResource::SO3_RESOURCE_PARTICLE_SYSTEM:
        Ogre::ScriptCompilerManager::getSingleton().parseScript(ds, groupName);
        break;
      case SResource::SO3_RESOURCE_TEXTURE:
        // Declare resource only, no parsing.
        ogreResourceGroupManager->declareResource(scriptName, "Texture", groupName);
        break;
      case SResource::SO3_RESOURCE_SKELETON:
        O3SkeletonManager->createResource(scriptName, groupName);
        O3SkeletonManager->load(scriptName, groupName);
              //O3SkeletonManager->parseScript(ds, groupName);
        break;
      case SResource::SO3_RESOURCE_GPUPROGRAM:
              // *.program files are managed by material script
        O3MaterialManager->parseScript(ds, groupName);
        break;
      case SResource::SO3_RESOURCE_HIGHLEVELGPUPROGRAM:
        //Ogre::GpuProgramManager::getSingleton().parseScript(ds, groupName);
        break;
    }
    
    // Reset the current scene in the resource loader
    SResourceLoader::getSingleton().SetResourceScene(0);
 
    // Close data stream
    if (ds)
    {
      ds->close();
      ds.reset();
    }
    return true;
  }
  catch(const Ogre::Exception& e)
  {
    // Reset the current scene in the resource loader
    SResourceLoader::getSingleton().SetResourceScene(0);
 
    // Cleaning opened data stream
    if(ds)
    {
      ds->close();
      ds.reset();
    }
 
    MMechostr(MSKRUNTIME, "SO3 Error while parsing %s : %s\n", scriptName.c_str(), e.what());
    return true;
  }
}
 
void SScene::DeleteAllNodes()
{
  // Delete all SNode and inherited objects. SBody, SAnimation, etc associated to any SNode are destroyed too.
  const SNodeMap nodeListCopy = nodeList;
  SNodeMap::const_iterator iNodeList = nodeListCopy.begin();
        while (iNodeList != nodeListCopy.end())
        {
    DeleteNode(iNodeList->second);
    iNodeList++;
        }
  nodeList.clear();
 
  // Clean ogre just in case...
        O3SceneManager->destroyAllEntities();
        O3SceneManager->destroyAllLights();
  O3SceneManager->destroyAllParticleSystems();
        //O3SceneManager->destroyAllCameras();
}
 
void SScene::DeleteAllAnimations()
{
  const SAnimMap seqAnimCopy = animationList;
  SAnimMap::const_iterator iSeqAnim = seqAnimCopy.begin();
        while (iSeqAnim != seqAnimCopy.end())
        {
    try
    {
      DeleteAnimation(iSeqAnim->second);
    }
    catch(Ogre::Exception&)
    {
      //not found
      0;
    }
    iSeqAnim++;
        }
  animationList.clear();
 
  // Clean ogre just in case...
  O3SceneManager->destroyAllAnimations();
        O3SceneManager->destroyAllAnimationStates();
}
 
void SScene::DeleteAllMaterials()
{
  const SGroupMaterialMap groupMaterialListCopy = listOfMaterial;
  SGroupMaterialMap::const_iterator iGroupMaterial = groupMaterialListCopy.begin();
        while (iGroupMaterial != groupMaterialListCopy.end())
        {
    const SMaterialMap materialListCopy = (*iGroupMaterial->second);
    SMaterialMap::const_iterator iMaterial = materialListCopy.begin();
    while(iMaterial != materialListCopy.end())
    {
      DeleteMaterial(iMaterial->second);
      iMaterial++;
          }
    iGroupMaterial++;
  }
  listOfMaterial.clear();
}
 
void SScene::DeleteAllTextures()
{
  // First, delete all the scene textures
  const SGroupTextureMap groupTextureListCopy = listOfTexture;
  SGroupTextureMap::const_iterator iGroupTexture = groupTextureListCopy.begin();
        while (iGroupTexture != groupTextureListCopy.end())
        {
    const STextureMap textureListCopy = (*iGroupTexture->second);
    STextureMap::const_iterator iTexture = textureListCopy.begin();
    while(iTexture != textureListCopy.end())
    {
      DeleteTexture(iTexture->second);
      iTexture++;
          }
    iGroupTexture++;
  }
  listOfTexture.clear();
 
  // Destroy all Textures not protected by /Core /BaseWhite /Stereo
  /*std::vector<Ogre::TexturePtr> listTextureToDelete;
        Ogre::ResourceManager::ResourceMapIterator itT = Ogre::TextureManager::getSingleton().getResourceIterator();
        while(itT.hasMoreElements())
        {
                Ogre::TexturePtr tex = static_cast<Ogre::TexturePtr>(itT.getNext());
                if((tex->getName() != "SO3DebugFontTexture")
     &&(tex->getName() != "BlueHighway-10Texture")
     &&(tex->getGroup() != "OgreInternal")
     &&(tex->getGroup().substr(0, std::string(SO3_INTERNAL_RESOURCE_GROUP).length()) != SO3_INTERNAL_RESOURCE_GROUP)
     &&(tex->getGroup() != SO3_INTERNAL_HYDRAX_RESOURCE_GROUP)
     &&(tex->getGroup() != SO3_INTERNAL_SKYX_RESOURCE_GROUP))
                {
      // ATTENTION: Store for further removal cause "O3TextureManager->remove" modify the iterator.
      listTextureToDelete.push_back(tex);
                }
        }
 
  // Now that Ogre iterator is processed, remove the texture that we do not need anymore.
  std::vector<Ogre::TexturePtr>::iterator iListTextureToDelete = listTextureToDelete.begin();
  while(iListTextureToDelete != listTextureToDelete.end())
  {
                        O3TextureManager->unload((*iListTextureToDelete)->getName());
                        O3TextureManager->remove((*iListTextureToDelete)->getName());
      iListTextureToDelete++;
  }
  listTextureToDelete.clear();*/
}
 
void SScene::SetDebugEnable(const bool& enable)
{
  if (SO3DebugOverlay)
  {
    if (enable)
      SO3DebugOverlay->show();
    else
      SO3DebugOverlay->hide();
  }
}
 
 
void SScene::SetDebugDisplay(const int& color, const int& posx, const int& posy, const int& width, const int& height, const int& charHeight)
{
  if (SO3DebugOverlay)
  {
    SO3DebugPanel->setMetricsMode(Ogre::GMM_PIXELS);
    SO3DebugPanel->setDimensions(Ogre::Real(width), Ogre::Real(height));
          SO3DebugPanel->setPosition(Ogre::Real(posx), Ogre::Real(posy));
 
          SO3DebugTextArea->setMetricsMode(Ogre::GMM_PIXELS);
          SO3DebugTextArea->setPosition(0.0, 0.0);
    SO3DebugTextArea->setDimensions(Ogre::Real(width), Ogre::Real(height));
          SO3DebugTextArea->setCharHeight(Ogre::Real(charHeight));
    SO3DebugTextArea->setColour(ConversionTools::ScolToOgreColorRGBA(color));
          SO3DebugTextArea->setColourBottom(ConversionTools::ScolToOgreColorRGBA(color));
          SO3DebugTextArea->setColourTop(ConversionTools::ScolToOgreColorRGBA(color));
          SO3DebugOverlay->show();
  }
}
 
void SScene::SetDebugText(const std::string& text)
{
  if (SO3DebugOverlay)
  {
    SO3DebugTextArea->setCaption(text);
    //SO3DebugTextArea->_update();
    //SO3DebugPanel->_update();
  }
}
 
void SScene::GetSimpleRayCast(Ogre::Ray cameraRay, SEntity* selected, SRaycastResult &result)
{
  mRayQuery->setRay(cameraRay);
  mRayQuery->setSortByDistance(true, 20);
  mRayQuery->setQueryTypeMask(Ogre::SceneManager::ENTITY_TYPE_MASK);
  Ogre::RaySceneQueryResult& qresult = mRayQuery->execute();
  Ogre::RaySceneQueryResult::iterator itr = qresult.begin();
 
  bool found = false;
  for (itr = qresult.begin(); itr != qresult.end() && !found; itr++)
  {
    /*
    if (itr->worldFragment)
    {
      Ogre::Real terrainHeight = itr->worldFragment->singleIntersection.y;
      continue;
    }
    else 
    */
    if (itr->movable && itr->movable->getVisible())
    {
      if (itr->movable->getMovableType() != "Entity")
        continue;
 
      Ogre::Entity* oentity = static_cast<Ogre::Entity*>(itr->movable);
      if (oentity->getNumSubEntities() == 0)
        continue;
 
      Ogre::SubEntity* subent = oentity->getSubEntity(0);
      Ogre::Any bindedCustomEntity = subent->getUserObjectBindings().getUserAny("SEntity");
      if (!bindedCustomEntity.has_value())
        continue;
 
      SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
      if (entity == selected)
      {
        result.entity = entity;
        result.entityName = entity->GetName();
        result.scene = this;
        result.sceneName = GetName();
        result.closestDistance = itr->distance;
        result.point = cameraRay.getOrigin() + (cameraRay.getDirection() * itr->distance);
        found = true;
      }
    }
  }
 
  mRayQuery->clearResults();
}
 
void SScene::GetSimpleRayCast(Ogre::Ray cameraRay, SRaycastResult &result)
{
  mRayQuery->setRay(cameraRay);
  mRayQuery->setSortByDistance(true, 20);
  Ogre::RaySceneQueryResult& qresult = mRayQuery->execute();
  Ogre::RaySceneQueryResult::iterator itr = qresult.begin();
 
  int lsize = 0;
 
  //get number of enabled entities
  for (itr = qresult.begin(); itr != qresult.end(); itr++)
  {
    /*
    if (itr->worldFragment)
    {
      Ogre::Real terrainHeight = itr->worldFragment->singleIntersection.y;
      continue;
    }
    else */
    if (itr->movable && itr->movable->getVisible())
    {
      if (itr->movable->getMovableType() != "Entity")
        continue;
 
      Ogre::Entity* oentity = static_cast<Ogre::Entity*>(itr->movable);
 
      if (oentity->getNumSubEntities() == 0)
        continue;
 
      Ogre::SubEntity* subent = oentity->getSubEntity(0);
      Ogre::Any bindedCustomEntity = subent->getUserObjectBindings().getUserAny("SEntity");
      if (!bindedCustomEntity.has_value())
        continue;
 
      SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
      if (entity && entity->GetSceneNodeIsMouseClick())
        lsize++;
    }
  }
 
  bool firstFound = false;
  int i = 0;
  for (itr = qresult.begin(); itr != qresult.end(); itr++)
  {
    /*
    if (itr->worldFragment)
    {
      Ogre::Real terrainHeight = itr->worldFragment->singleIntersection.y;
      //TODO terrain
    }
    else */ 
    if (itr->movable && itr->movable->getVisible())
    {
      if (itr->movable->getMovableType() != "Entity")
        continue;
 
      Ogre::Entity* oentity = static_cast<Ogre::Entity*>(itr->movable);
      if (oentity->getNumSubEntities() == 0)
        continue;
 
      Ogre::SubEntity* subent = oentity->getSubEntity(0);
      Ogre::Any bindedCustomEntity = subent->getUserObjectBindings().getUserAny("SEntity");
      if (!bindedCustomEntity.has_value())
        continue;
 
      SEntity* entity = Ogre::any_cast<SEntity*> (bindedCustomEntity);
      if (entity && entity->GetSceneNodeIsMouseClick() && (!firstFound || entity->GetSceneNodeIsMouseForeground()))
      {
        i++;
 
        //if the camera is in the bounding box we ignore it
        if (oentity->getWorldBoundingBox().contains(cameraRay.getOrigin()) && (i < lsize))
          continue;
 
        firstFound = true;
        result.entity = entity;
        result.entityName = entity->GetName();
        result.scene = this;
        result.sceneName = GetName();
        result.material = GetMaterial(entity->GetGroupName(), subent->getMaterial()->getName());
        result.indexSubEntity = 0;
        result.closestDistance = itr->distance;
        result.point = cameraRay.getOrigin() + (cameraRay.getDirection() * itr->distance);
 
        if (entity->GetSceneNodeIsMouseForeground())
          break;
      }
    }
  }
 
  mRayQuery->clearResults();
}
 
void SScene::SetMaterialsPointSize(Ogre::Real size)
{
  SGroupMaterialMap::const_iterator iGroupMaterial = listOfMaterial.begin();
  while (iGroupMaterial != listOfMaterial.end())
  {
    const SMaterialMap materialList = (*iGroupMaterial->second);
    SMaterialMap::const_iterator iMaterial = materialList.begin();
    while (iMaterial != materialList.end())
    {
      iMaterial->second->SetPointSize(size);
      iMaterial++;
    }
    iGroupMaterial++;
  }
}
 
}