SO3Engine/SO3SceneGraph/SO3Scene.cpp

Go to the documentation of this file.

#include "SO3Scene.h"
#include "../ScolPack/SO3Scol.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/SO3DynamicReflectionMap.h"
#include "../SO3PhysicGraph/SO3Body.h"
#include "../SO3PhysicGraph/SO3MaterialPair.h"
#include "../SO3PhysicGraph/SO3MaterialID.h"
#include "../SO3Renderer/SO3Root.h"
#include "../SO3SceneGraph/SO3Bone.h"
#include "../SO3SceneGraph/SO3EntityFap.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"

// using scolSDK
#include        <scol.h>  

extern WindowHandle hwndScol;
extern int SCENE_PRE_RENDER_EVENT;
extern int SCENE_POST_RENDER_EVENT;
extern int ANIMATION_END_EVENT;

extern int SO3_BODY_LEAVE_WORLD_MSG;
extern int getMaterialOverlapStartedCallback(mmachine m, int id, MCOLL * result);
extern int getMaterialContactCallback(mmachine m, int id, MCOLL * result);
extern int getMaterialOverlapEndedCallback(mmachine m, int id, MCOLL * result);
extern SMaterialPair* getMaterialPairByWorld(SPhysicWorld* world, int ID1, int ID2);


namespace SO3
{

SO3MainFrameListener::SO3MainFrameListener(SScene* scene) : FrameListener()
{
  m_scene = scene;
}

SO3MainFrameListener::~SO3MainFrameListener(void)
{

}

bool SO3MainFrameListener::frameStarted(const Ogre::FrameEvent &evt)
{
  int time = static_cast<int>(evt.timeSinceLastFrame * 1000);
  SendMessage(hwndScol, SCENE_PRE_RENDER_EVENT, (int)m_scene, (LPARAM)time);
  
  SPhysicWorld* physic_world = m_scene->GetPhysicsWorld();

  //$BB apply physics after render callback
  if (physic_world->GetPhysicWorld() != 0)
    //invalidateCache must not be done in world update
    if (physic_world->GetResetPhysicWorld())
    {
      physic_world->physicContactOverlapStartMap.clear();
      physic_world->physicContactMap.clear();
      physic_world->bodyPairMap.clear();

      physic_world->GetPhysicWorld()->invalidateCache();
      physic_world->SetResetPhysicWorld(false);
    }

    if (physic_world->GetPhysicWorldEnable())
    {
      physic_world->GetPhysicWorld()->update(evt.timeSinceLastFrame);
      
      if (physic_world->GetPhysicDebugEnable())
        physic_world->GetPhysicDebugger()->showDebugInformation();
      
      //$BB send callbacks here to be sure that no scol or other code will be executed while the physic update loop
      //send overlap start callbacks
      const PhysicContactMap lOverlapStart = physic_world->physicContactOverlapStartMap;
      PhysicContactMap::const_iterator iOverlapStartMap = lOverlapStart.begin();
      while (iOverlapStartMap != lOverlapStart.end())
      {
        MCOLL* mCollResult = iOverlapStartMap->second;
        getMaterialOverlapStartedCallback(mm, (int)mCollResult->matPair, mCollResult);

        // Release memory.
        delete(mCollResult);

        iOverlapStartMap++;
      }
      physic_world->physicContactOverlapStartMap.clear();
  
      //send contact callbacks
      const PhysicContactMap lContacts = physic_world->physicContactMap;
      PhysicContactMap::const_iterator iContactMap = lContacts.begin();
      while (iContactMap != lContacts.end())
      {
        MCOLL* mCollResult = iContactMap->second;
        getMaterialContactCallback(mm, (int)mCollResult->matPair, mCollResult);

        // Release memory.
        delete(mCollResult);

        iContactMap++;
      }
      physic_world->physicContactMap.clear();

      const BodyPairMap bodyPairList = physic_world->bodyPairMap;
      // Parsing all bodies that were detected in contact
      BodyPairMap::const_iterator iBodyPairMap = bodyPairList.begin();
      while (iBodyPairMap != bodyPairList.end())
      {
        // Checking if bodies are still in contact. Note that NewtonBodyGetFirstContactJoint() is not binded in OgreNewt for the moment.
        bool bodiesInContact = false;
        SBody** bpair = iBodyPairMap->second;
        SBody* fbody0 = bpair[0];
        SBody* fbody1 = bpair[1];
        if ((fbody0 != NULL) && (fbody1 != NULL))
        {
          OgreNewt::Body* nbody0 = fbody0->getOgreNewtBodyPointer();
          OgreNewt::Body* nbody1 = fbody1->getOgreNewtBodyPointer();
            
          if ((nbody0 != NULL) && (nbody1 != NULL))
          {
            NewtonBody* b0 = nbody0->getNewtonBody();
            NewtonBody* b1 = nbody1->getNewtonBody();
            NewtonJoint* contactJoint = NewtonBodyGetFirstContactJoint(b0);

            while((contactJoint) && (!bodiesInContact))
            {
              // Get infos about the bodies of contact from Newton
              NewtonBody* b0Bis = NewtonJointGetBody0(contactJoint);
              NewtonBody* b1Bis = NewtonJointGetBody1(contactJoint);

              // Is the body still in contact with the second body of the pair value?
              if(((b0Bis == b0)&&(b1Bis == b1)) || ((b0Bis == b1)&&(b1Bis == b0)))
                bodiesInContact = true;
              else
                contactJoint = NewtonBodyGetNextContactJoint(b0, contactJoint);
            }

            // If not, remove the bodies pair from the map.
            if(!bodiesInContact)
            {
              // Getting the material pair. TODO: cleaner way to parse MaterialPair list
              SMaterialPair* matPair = 0;
              const SMaterialPairMap materialPairList = physic_world->listOfPhysicsMaterialPair;
              SMaterialPairMap::const_iterator iMaterialPairList = materialPairList.begin();
              while((iMaterialPairList != materialPairList.end()) && (!matPair))
              {
                if(((*iMaterialPairList)->getID1() == fbody0->GetMaterialID()->getID() && (*iMaterialPairList)->getID2() == fbody1->GetMaterialID()->getID())
                  ||((*iMaterialPairList)->getID2() == fbody0->GetMaterialID()->getID() && (*iMaterialPairList)->getID1() == fbody1->GetMaterialID()->getID())) 
                        matPair = *iMaterialPairList;

                iMaterialPairList++;
              }

              if(matPair != 0)
              {
                // Construct CollResult
                MCOLL* mCollResult = new MCOLL();
                mCollResult->node0 = fbody0->GetParentNode()->GetName();
                mCollResult->node1 = fbody1->GetParentNode()->GetName();
                mCollResult->curScene = m_scene;

                // Send contact end callback to scol virtual machine.
                if (matPair->GetOverlapEndedCallbackActivated())
                  getMaterialOverlapEndedCallback(mm, (int)matPair, mCollResult);

                // Release memory.
                delete(mCollResult);
              }

              // erase the entry from the map.
              free(bpair);
              physic_world->bodyPairMap.erase(iBodyPairMap->first);
            }
          }
        }
        // Next couple.
        iBodyPairMap++;
      }
    }
  return true;
}

bool SO3MainFrameListener::frameEnded(const Ogre::FrameEvent &evt)
{
  int time = static_cast<int>(evt.timeSinceLastFrame * 1000);
  SendMessage(hwndScol, SCENE_POST_RENDER_EVENT, (int)m_scene, (LPARAM)time);
  return true;
}


SO3ParticleFrameListener::SO3ParticleFrameListener(SScene* scene) : FrameListener()
{
        m_scene = scene;
}

SO3ParticleFrameListener::~SO3ParticleFrameListener(void)
{
}

bool SO3ParticleFrameListener::frameStarted(const Ogre::FrameEvent &evt)
{
        return true;
}

bool SO3ParticleFrameListener::frameEnded(const Ogre::FrameEvent &evt)
{
        return true;
}

SScene::SScene(SRoot* parent, std::string sceneName, int scolChannel) : SData(sceneName), channel(scolChannel)
{
  scolRoot = parent;
  O3SceneManager = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, sceneName);
  
  animationCounter = 0;
        skyBoxMat.setNull();
        skyDomeMat.setNull();
        skyPlaneMat.setNull();
        hasSkyBox = false;
        skyBoxDrawFirst = false;
        hasSkyDome = false;
        skyDomeDrawFirst = false;
        hasSkyPlane = false;
        skyPlaneDrawFirst = false;
        shadowCameraSetup = SO3_DEFAULT_SHADOW_CAMERA;
  materialCaster.setNull();
  materialReceiver.setNull();

  O3MeshManager =  Ogre::MeshManager::getSingletonPtr();
        O3MaterialManager = Ogre::MaterialManager::getSingletonPtr();
        O3TextureManager = Ogre::TextureManager::getSingletonPtr();
        O3HighLevelGpuProgramManager = Ogre::HighLevelGpuProgramManager::getSingletonPtr();
        O3SkeletonManager = Ogre::SkeletonManager::getSingletonPtr();
        O3GpuProgramManager = Ogre::GpuProgramManager::getSingletonPtr();
  O3ParticleSystemManager = Ogre::ParticleSystemManager::getSingletonPtr();
        
  mainListener = new SO3MainFrameListener(this);
        Ogre::Root::getSingleton().addFrameListener(mainListener);

        particleListener = new SO3ParticleFrameListener(this);
        Ogre::Root::getSingleton().addFrameListener(particleListener);

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

SScene::SScene() : SData(""), channel(0)
{
  // Forbiden (private).
}

void SScene::clearOgreScene() 
{
  // ! 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, and that could be destroy in the lines below.
  SAFE_DELETE(environment);

  const SNodeMap nodeListCopy = GetNodeList();
  SNodeMap::const_iterator iNodeList = nodeListCopy.begin();
        while (iNodeList != nodeListCopy.end())
        {
    if (iNodeList->second != 0)
      DeleteNode(iNodeList->second);
    
    iNodeList++;
        }
  
  //clear physic material pair callback
  const BodyPairMap bodyListCopy = physicWorld->bodyPairMap;
  BodyPairMap::const_iterator iBodyMap = bodyListCopy.begin();
        while (iBodyMap != bodyListCopy.end())
        {
    free(iBodyMap->second);
    physicWorld->bodyPairMap.erase(iBodyMap->first);
    
    iBodyMap++;
        }

  //clear sequence animations
  const SAnimMap seqAnimCopy = animationList;
  SAnimMap::const_iterator iSeqAnim = seqAnimCopy.begin();
        while (iSeqAnim != seqAnimCopy.end())
        {
    DeleteAnimation(iSeqAnim->second);    
    iSeqAnim++;
        }

  // ! OgreNewton disable
  physicWorld->SetPhysicWorldEnable(false);

  // ! Destroy Scene Manager Objects and resources
        Ogre::ShadowTextureManager::getSingleton().clear();
        O3SceneManager->setShadowTechnique(Ogre::SHADOWTYPE_NONE);

  //$BB Why Snode not enought ?
        O3SceneManager->destroyAllEntities();
        O3SceneManager->destroyAllLights();
  O3SceneManager->destroyAllParticleSystems();
        //O3SceneManager->destroyAllCameras();

        O3SceneManager->destroyAllAnimations();
        O3SceneManager->destroyAllAnimationStates();
        O3SceneManager->destroyAllBillboardChains();
        O3SceneManager->destroyAllBillboardSets();
  O3ParticleSystemManager->removeAllTemplates(true);
  O3SceneManager->destroyAllRibbonTrails();

  O3SkeletonManager->unloadAll(false);
  O3SkeletonManager->removeAll();

  // ! Clear Ogre Scene
        O3SceneManager->clearScene();

  // ! Skies Destruction
        O3SceneManager->destroyAllInstancedGeometry();
        Ogre::SceneManager::MovableObjectIterator itMO = O3SceneManager->getMovableObjectIterator("ManualObject");
        while(itMO.hasMoreElements())
        {
                Ogre::ManualObject * curObj = static_cast<Ogre::ManualObject*>(itMO.getNext());
                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());

  // ! Destroy Textures
  // 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() != "Internal")
     &&(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();

  // ! Reset fog setting
  O3SceneManager->setFog(Ogre::FOG_NONE, Ogre::ColourValue::White, 0, 0, 0);

  // Everithing was resetted, we can re-create our environment.
  environment = new SEnvironment(this, name);
}

SScene::~SScene()
{
        //$BB remove scene from scene list
/* TODO DELETE  SSceneMap::iterator iSceneSearched = scolRoot->sceneList.find(this->O3SceneManager->getName());
  if(iSceneSearched != scolRoot->sceneList.end())
    scolRoot->sceneList.erase(iSceneSearched);
*/
        //$BB destroy main listener
        if (mainListener != NULL)
        {
                Ogre::Root::getSingleton().removeFrameListener(mainListener);
                SAFE_DELETE(mainListener);
        }

        if (particleListener != NULL)
        {
                Ogre::Root::getSingleton().removeFrameListener(particleListener);
                SAFE_DELETE(particleListener);
        }

  SAFE_DELETE(environment);
  clearOgreScene();
  
        SAFE_DELETE(physicWorld);
  SAFE_DELETE(rootNode);

        nodeList.clear();
        listOfMaterial.clear();
        listOfTexture.clear();

  Ogre::Root::getSingleton().destroySceneManager(O3SceneManager);
}

void 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));
  }
  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!", "SScene::AddNode");
  }
}

void SScene::RemoveNode(SNode* existingNode)
{
  RemoveNode(existingNode->GetName());
}

void SScene::RemoveNode(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(std::string nodeName)
{
  SNodeMap::iterator iNodeSearched = nodeList.find(nodeName);
  if (iNodeSearched != nodeList.end())
    return iNodeSearched->second;
  else
    return 0;
}

const SNodeMap& SScene::GetNodeList() const
{
  return nodeList;
}

SNode* SScene::CreateNode(std::string newNodeName)
{
  SNode* newNode = new SNode(this, newNodeName);
  AddNode(newNode);
  return newNode;
}

void SScene::DeleteNode(SNode* existingNode)
{
  if (existingNode != rootNode)
  {
    RemoveNode(existingNode);
    SAFE_DELETE(existingNode);
  }
}

SCamera* SScene::CreateCamera(std::string newCameraName)
{
  SCamera* newCamera = new SCamera(this, newCameraName);
  AddNode(newCamera);
  return newCamera;
}

void SScene::DeleteCamera(SCamera* existingCamera)
{
  DeleteNode(existingCamera);
}

SEntity* SScene::CreateEntity(std::string groupName, std::string newEntityName, std::string meshName)
{
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, meshName);
  AddNode(newEntity);
  return newEntity;
}

SEntityFap* SScene::CreateEntityFap(std::string newEntityFapName, std::string meshName, std::string pathStdFDP, std::string pathStdIndices)
{
  // Create the entity.
  SEntityFap* newEntityFap = new SEntityFap(this, newEntityFapName, meshName, pathStdFDP, pathStdIndices);
  AddNode(newEntityFap);
  return newEntityFap;
}

SEntity* SScene::CreateEntity(std::string newEntityName, SEntity::EntityPrefabType prefabType)
{
  SEntity* newEntity = new SEntity(this, newEntityName, prefabType);
  AddNode(newEntity);
  return newEntity;
}

SEntity* SScene::CreatePlane(std::string groupName, std::string newEntityName, SPointFloat sizev, SPointInt seg, SPointFloat uv)
{
  SEntity* newEntity = new SEntity(this, groupName, newEntityName, sizev, seg, uv);
  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++;
  }
}

SSkeleton* SScene::CreateSkeleton(std::string newSkeletonName, SEntity* entity)
{
  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(std::string newBoneName, SSkeleton* skeleton, unsigned short id)
{
  SBone* newBone = new SBone(this, newBoneName, skeleton, id);
  AddNode(newBone);
  return newBone;
}

void SScene::DeleteBone(SBone* existingBone)
{
  DeleteNode(existingBone);
}

SParticleSystem* SScene::CreateParticleSystem(std::string newParticleSystemName, std::string particleSystemTemplate)
{
  SParticleSystem* newParticleSystem = new SParticleSystem(this, newParticleSystemName, particleSystemTemplate);
  AddNode(newParticleSystem);
  return newParticleSystem;
}

void SScene::DeleteParticleSystem(SParticleSystem* existingParticleSystem)
{
  DeleteNode(existingParticleSystem);
}

SLight* SScene::CreateLight(std::string newLightName)
{
  SLight* newLight = new SLight(this, newLightName);
  AddNode(newLight);
  return newLight;
}

void SScene::DeleteLight(SLight* existingLight)
{
  DeleteNode(existingLight);
}

SDynamicCubeMap* SScene::CreateDynamicCubeMap(std::string newDynamicCubeMapName)
{
  SDynamicCubeMap* newDynamicCubeMap = new SDynamicCubeMap(this, newDynamicCubeMapName);
  AddNode(newDynamicCubeMap);
  return newDynamicCubeMap;
}

void SScene::DeleteDynamicCubeMap(SDynamicCubeMap* existingDynamicCubeMap)
{
  DeleteNode(existingDynamicCubeMap);
}

SDynamicReflectionMap* SScene::CreateDynamicReflectionMap(SViewPort* viewport, std::string newDynamicReflectionMapName)
{
  SDynamicReflectionMap* newDynamicReflectionMap = new SDynamicReflectionMap(this, viewport, newDynamicReflectionMapName);
  AddNode(newDynamicReflectionMap);
  return newDynamicReflectionMap;
}

void SScene::DeleteDynamicReflectionMap(SDynamicReflectionMap* existingDynamicReflectionMap)
{
  DeleteNode(existingDynamicReflectionMap);
}

SMaterial* SScene::CreateMaterial(std::string groupname, std::string matname)
{
  // search for existing material
  if (GetMaterial (groupname, matname))
    return 0;

  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);
  materialMap->insert(SMaterialMap::value_type(matname, material));
  return material;
}

void SScene::DeleteMaterial(SMaterial* material)
{
  //TODO delete group and SMaterialMap when list is empty
  SGroupMaterialMap::iterator iGroupSearched = listOfMaterial.find(material->GetGroupName());
  if(iGroupSearched != listOfMaterial.end())
  {
    SMaterialMap* materialMap = static_cast<SMaterialMap*> (iGroupSearched->second);
    SMaterialMap::iterator iMaterialSearched = materialMap->find(material->GetName());
    if(iMaterialSearched != materialMap->end())
      materialMap->erase(iMaterialSearched);

    if(materialMap->empty())
    {
      listOfMaterial.erase(iGroupSearched);
      delete (materialMap);
    }
  }
  delete(material);
}

SMaterial* SScene::GetMaterial(std::string groupName, std::string materialName)
{
  SGroupMaterialMap::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;
    }
    return 0;
  }
  return 0;
}

STexture* SScene::CreateTexture(std::string groupname, std::string texname, std::string path, int w, int h)
{
  // search for existing material
  if (GetTexture (groupname, texname))
    return 0;
  
  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));
  }

  STexture* texture = new STexture(this, groupname, texname, path, w, h);
  textureMap->insert(STextureMap::value_type(texname, texture));
  return texture;
}

void SScene::DeleteTexture(STexture* 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().isNull())
  {
    O3TextureManager->unload(texture->getOgreTexturePointer()->getHandle());
          O3TextureManager->remove(texture->getOgreTexturePointer()->getHandle());
  }
  delete(texture);
}

STexture* SScene::GetTexture(std::string groupName, 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;
}

SRoot* SScene::GetParent()
{
  return scolRoot;
}

SPhysicWorld* SScene::GetPhysicsWorld()
{
  return physicWorld;
}

SSequenceAnimation* SScene::CreateAnimationSequence(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);
  SAFE_DELETE(existingAnimation);
}

unsigned short SScene::GetNumAnimations()
{
  return animationList.size();
}

SAnim* SScene::GetAnimation(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();
  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.
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Can not add animation named \""+ animationName +"\", an element with the same name already exist!", "SScene::AddAnimation");
  }
}

void SScene::RemoveAnimation(SAnim* existingAnimation)
{
  RemoveAnimation(existingAnimation->GetName());
}

void SScene::RemoveAnimation(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;
}

}

---