Fix css style order when using external css files

[ryzomcore.git] / ryzom / client / src / scene_parser.cpp

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#include "stdpch.h"


/////////////
// INCLUDE //
/////////////
// Misc.
#include "nel/misc/path.h"
#include "nel/misc/debug.h"
#include "nel/misc/matrix.h"
// 3D Interface.
#include "nel/3d/u_driver.h"
#include "nel/3d/u_scene.h"
#include "nel/3d/u_play_list.h"
#include "nel/3d/u_track.h"
#include "nel/3d/u_camera.h"
// Client.
#include "scene_parser.h"
#include "entities.h"
#include "entity_cl.h"
#include "animated_scene_object.h"
#include "ig_client.h"
#include "user_controls.h"
#include "time_client.h"
// Game Share
#include "game_share/entity.h"


///////////
// USING //
///////////
using namespace NLMISC;
using namespace NL3D;
using namespace std;


////////////
// EXTERN //
////////////
extern UDriver          *Driver;
extern UScene           *Scene;
extern UScene           *SceneRoot;


/////////////
// METHODS //
/////////////
const uint CSceneParser::MAX_LINE_SIZE = 500;
const char *CSceneParser::delimiter = " \t";

//-----------------------------------------------
// CSceneParser :
// Constructor.
//-----------------------------------------------
CSceneParser::CSceneParser()
{
        _FrameRate = 30.0;
        _Line = 0;
        _AnimationSet = 0;
        _TimeStart = -1;
        _AnimationSet = 0;
        _Apply = false;
        _Day = true;

        _ItScene = _Scene.end();
        _SceneStart = -1.f;
}// CSceneParser //


//-----------------------------------------------
// load :
// Load the file with the scene.
//-----------------------------------------------
void CSceneParser::load(const string &filename)
{
        // Look for the file -> nlwarning and return if sceneFile is empty.
        string sceneFile = CPath::lookup(filename, false);
        if(sceneFile.empty())
        {
                nlwarning("CSceneParser::load : Can't find file \"%s\".", filename.c_str());
                return;
        }

        // Open the file.
        ifstream file(sceneFile.c_str(), ios::in);
        if(file.is_open())
        {
                // Load the capture speed.
                ifstream speedFile("capture_speed.txt", ios::in);
                if(speedFile.is_open())
                {
                        char tmpBuff[MAX_LINE_SIZE];

                        // Set the default fram rate (30fps).
                        _FrameRate = 30.0;

                        // Init Lines.
                        _Line = 0;

                        // While the end of the file is not reached -> parse the script.
                        while(!speedFile.eof())
                        {
                                // Get next valid line.
                                getNextValidLine(speedFile, tmpBuff);

                                char *ptr = strtok(tmpBuff, delimiter);
                                if(ptr != NULL)
                                        NLMISC::fromString(ptr, _FrameRate);
                        }

                        // Close the speed file.
                        speedFile.close();
                }
                else
                        nlwarning("CSceneParser::load : 'capture_speed.txt' can't be open, default frame rate is %f.", _FrameRate);

                // Init Lines.
                _Line = 0;

                // Parse the File.
                parse(file);

                // Initialize Actors Position and rotation .
                initActors();

                // Close the File.
                file.close();
        }
        else
        {
                nlwarning("CSceneParser::load : File \"%s\" can't be open.", sceneFile.c_str());
                return;
        }
}// load //


//-----------------------------------------------
// parse :
// Parse the file.
//-----------------------------------------------
void CSceneParser::parse(ifstream &file)
{
        char tmpBuff[MAX_LINE_SIZE];

        // While the end of the file is not reached -> parse the script.
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, tmpBuff);

                char *ptr = strtok(tmpBuff, delimiter);
                if(ptr != NULL)
                {
                        // Time (Day/Night)
                        if(strcmp(ptr, "Time:") == 0)
                                parseTime();

                        // Filename of the File with all IG to load for the scene.
                        else if(strcmp(ptr, "IG:") == 0)
                                parseIG(file, tmpBuff);

                        // Ig for the init.
                        else if(strcmp(ptr, "IG_Init:") == 0)
                                parseIGInit();

                        // Particle.
                        else if(strcmp(ptr, "Particle:") == 0)
                                parseParticle(file, tmpBuff);

                        // Actor.
                        else if(strcmp(ptr, "Actor:") == 0)
                                parseActor(file, tmpBuff);

                        // Camera.
                        else if(strcmp(ptr, "Camera:") == 0)
                                parseCamAnims(file, tmpBuff);

                        // Action.
                        else if(strcmp(ptr, "Sequence:") == 0)
                                parseSequence(file, tmpBuff);

                        // Bad Keyword
                        else
                                nlwarning("Unknown keyword '%s' at line %d.", ptr, _Line);
                }
        }
}// parse //


//-----------------------------------------------
// getNextValidLine :
// Skip empty lines and comment lines.
//-----------------------------------------------
void CSceneParser::getNextValidLine(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get the line.
                file.getline(buff, MAX_LINE_SIZE);

                // Increase line nnumber.
                _Line++;

                // Skip comments.
                if(buff[0] != 0)
                {
                        // First char is not the beginning of a comment.
                        if(buff[0] != '/')
                                break;
                        // Second char is not the end of a coment.
                        else if(buff[1] != '/')
                                break;
                }
        }
}// getNextValidLine //


//-----------------------------------------------
// parseTime :
// Day or Night.
//-----------------------------------------------
void CSceneParser::parseTime()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
        {
                if(atoi(ptr))
                        _Day = true;
                else
                        _Day = false;
        }
}// parseTime //

//-----------------------------------------------
// parseIG :
// Parse the list of IG to load for the scene
//-----------------------------------------------
void CSceneParser::parseIG(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_IG") == 0)
                                break;
                        // IG Name.
                        else
                                _IG.push_back(ptr);
                }
        }
}// parseIG //

//-----------------------------------------------
// parseIGInit :
// Get the name of the IG to initialize entities.
//-----------------------------------------------
void CSceneParser::parseIGInit()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _IG_Init = ptr;
}// parseIGInit //


///////////////
// PARTICLES //
//-----------------------------------------------
// parseParticle :
// Parse Particle.
//-----------------------------------------------
void CSceneParser::parseParticle(ifstream &file, char *buff)
{
        // Reset the current particle.
        _CurrentParticle.reset();

        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Particle") == 0)
                                break;

                        // Particle's Id
                        else if(strcmp(ptr, "Id:") == 0)
                                parseParticleId();

                        // Particle's IG
                        else if(strcmp(ptr, "IG:") == 0)
                                parseParticleIG();

                        // Particle's Cluster
                        else if(strcmp(ptr, "Cluster:") == 0)
                                parseParticleCluster();

                        // Actor father of the particle is there is one.
                        else if(strcmp(ptr, "Actor:") == 0)
                                parseParticleActor();

                        // Particle's Anims
                        else if(strcmp(ptr, "Anims:") == 0)
                                parseParticleAnims(file, buff);

                        // Bad Keyword
                        else
                                nlwarning("Unknown keyword '%s' at line %d.", ptr, _Line);
                }
        }

        // If the current particle Id is Valid -> create the particle.
        if(_CurrentParticle.Id >= 0)
        {
                map<uint, CParticle>::iterator it = _Particles.find((uint)_CurrentParticle.Id);
                // Id already exists.
                if(it != _Particles.end())
                        nlwarning("Particle before line %d has the ID %d that already exists -> Particle Not Created.", _Line, _CurrentParticle.Id);
                // Insert the new Particle.
                else
                        _Particles.insert(make_pair((uint)_CurrentParticle.Id, _CurrentParticle));
        }
        else
                nlwarning("Particle before line %d has no ID or a Bad one -> Particle Not Created.", _Line);
}// parseParticle //

//-----------------------------------------------
// parseParticleId :
// Parse Particle's Id.
//-----------------------------------------------
void CSceneParser::parseParticleId()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentParticle.Id = atoi(ptr);
}// parseParticleId //

//-----------------------------------------------
// parseParticleIG :
// Parse Particle's IG.
//-----------------------------------------------
void CSceneParser::parseParticleIG()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentParticle.IG = ptr;
}// parseParticleIG //

//-----------------------------------------------
// parseParticleCluster :
// Parse Particle's Cluster.
//-----------------------------------------------
void CSceneParser::parseParticleCluster()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentParticle.Cluster = ptr;
}// parseParticleCluster //

//-----------------------------------------------
// parseParticleActor :
// Parse Particle's Actor.
//-----------------------------------------------
void CSceneParser::parseParticleActor()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentParticle.Actor = atoi(ptr);
}// parseParticleActor //

//-----------------------------------------------
// parseParticleAnims :
// Parse Particle's anims.
//-----------------------------------------------
void CSceneParser::parseParticleAnims(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Anims") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CurrentParticle.Anims.push_back(ptr);
                }
        }
}// parseParticleAnims //


////////////
// ACTORS //
//-----------------------------------------------
// parseActor :
// Parse an actor.
//-----------------------------------------------
void CSceneParser::parseActor(ifstream &file, char *buff)
{
        // Reset the current actor.
        _CurrentActor.reset();

        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Actor") == 0)
                                break;

                        // Actor's Id
                        else if(strcmp(ptr, "Id:") == 0)
                                parseId();

                        // Actor's Name
                        else if(strcmp(ptr, "Name:") == 0)
                                parseName();

                        // Is the Actor a flyer.
                        else if(strcmp(ptr, "Fly:") == 0)
                                parseFly();

                        // Actor father of the particle is there is one.
                        else if(strcmp(ptr, "Actor:") == 0)
                                parseActorActor();

                        // Actor's Skeleton
                        else if(strcmp(ptr, "Skel:") == 0)
                                parseSkel();

                        // Actor's Meshes
                        else if(strcmp(ptr, "Meshes:") == 0)
                                parseMeshes(file, buff);

                        // Actor's Anims
                        else if(strcmp(ptr, "Anims:") == 0)
                                parseAnims(file, buff);

                        // Bad Keyword
                        else
                                nlwarning("Unknown keyword '%s' at line %d.", ptr, _Line);
                }
        }

        // If the current actor Id is Valid -> create the actor.
        if(_CurrentActor.Id >= 0)
        {
                map<uint, CActor>::iterator it = _Actors.find((uint)_CurrentActor.Id);
                // Id already exists.
                if(it != _Actors.end())
                        nlwarning("Actor before line %d has the ID %d that already exists -> Actor Not Created.", _Line, _CurrentActor.Id);
                // Insert the new actor.
                else
                        _Actors.insert(make_pair((uint)_CurrentActor.Id, _CurrentActor));
        }
        else
                nlwarning("Actor before line %d has no ID or a Bad one -> Actor Not Created.", _Line);
}// parseActor //

//-----------------------------------------------
// parseId :
// Parse the current actor Id.
//-----------------------------------------------
void CSceneParser::parseId()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentActor.Id = atoi(ptr);
}// parseId //

//-----------------------------------------------
// parseName :
// Parse the current actor Name.
//-----------------------------------------------
void CSceneParser::parseName()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentActor.Name = ptr;
}// parseName //

//-----------------------------------------------
// parseFly :
// Is the Actor a flyer.
//-----------------------------------------------
void CSceneParser::parseFly()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
        {
                if(atoi(ptr))
                        _CurrentActor.Fly = true;
                else
                        _CurrentActor.Fly = false;
        }
}// parseFly //

//-----------------------------------------------
// parseActorActor :
// Parse Actor's Actor.
//-----------------------------------------------
void CSceneParser::parseActorActor()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
        {
                _CurrentActor.Actor = atoi(ptr);
                nlwarning("Actor: %d Follow : %d", _CurrentActor.Id, _CurrentActor.Actor);
        }
}// parseActorActor //

//-----------------------------------------------
// parseSkel :
// Parse the current actor Skeleton Name.
//-----------------------------------------------
void CSceneParser::parseSkel()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentActor.Skeleton = ptr;
}// parseSkel //

//-----------------------------------------------
// parseMeshes :
// Parse meshes used for the current actor.
//-----------------------------------------------
void CSceneParser::parseMeshes(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Meshes") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CurrentActor.Meshes.push_back(ptr);
                }
        }
}// parseMeshes //

//-----------------------------------------------
// parseAnims :
// Parse anims used for the current actor.
//-----------------------------------------------
void CSceneParser::parseAnims(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Anims") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CurrentActor.Anims.push_back(ptr);
                }
        }
}// parseAnims //


////////////
// CAMERA //
//-----------------------------------------------
// parseCamAnims :
// Parse all anims used for the camera in all sequence.
//-----------------------------------------------
void CSceneParser::parseCamAnims(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of Anims for the camera.
                        if(strcmp(ptr, "End_Camera") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CamAnims.push_back(ptr);
                }
        }
}// parseCamAnims //


///////////////
// SEQUENCES //
//-----------------------------------------------
// parseSequence :
// Parse a sequence.
//-----------------------------------------------
void CSceneParser::parseSequence(ifstream &file, char *buff)
{
        // Reset the current sequence.
        _CurrentSequence.reset();

        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Sequence") == 0)
                                break;

                        // Sequence Id.
                        else if(strcmp(ptr, "Id:") == 0)
                                parseSeqId();

                        // Particle for the sequence.
                        else if(strcmp(ptr, "Particle:") == 0)
                                parseSeqParticle(file, buff);

                        // Actor for the sequence.
                        else if(strcmp(ptr, "Actor:") == 0)
                                parseSeqActor(file, buff);

                        // Camera for the sequence.
                        else if(strcmp(ptr, "Camera:") == 0)
                                parseSeqCam(file, buff);

                        // Bad Keyword
                        else
                                nlwarning("Unknown keyword '%s' at line %d.", ptr, _Line);
                }
        }

        // If the sequence Id is Valid -> create the sequence.
        if(_CurrentSequence.Id >= 0)
        {
                map<uint, CSequence>::iterator itSeq = _Sequences.find((uint)_CurrentSequence.Id);
                // Id already exists.
                if(itSeq != _Sequences.end())
                        nlwarning("Sequence before line %d has the ID %d that already exists -> Sequence Not Created.", _Line, _CurrentSequence.Id);
                // Insert the new actor.
                else
                        _Sequences.insert(make_pair((uint)_CurrentSequence.Id, _CurrentSequence));
        }
        else
                nlwarning("Sequence before line %d has no ID or a Bad one -> Sequence Not Created.", _Line);
}// parseSequence //

//-----------------------------------------------
// parseSeqId :
// Parse the current sequence Id.
//-----------------------------------------------
void CSceneParser::parseSeqId()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentSequence.Id = atoi(ptr);
}// parseSeqId //

//-----------------------------------------------
// parseSeqParticle :
// Parse particle in the sequence.
//-----------------------------------------------
void CSceneParser::parseSeqParticle(ifstream &file, char *buff)
{
        // Reset the current particle in the sequence.
        _CurParticleSeq.reset();

        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Particle") == 0)
                                break;

                        // Actor in Sequence Id.
                        else if(strcmp(ptr, "Id:") == 0)
                                parseSeqParticleId();

                        // Actor in Sequence anims.
                        else if(strcmp(ptr, "Anims:") == 0)
                                parseSeqParticleAnims(file, buff);

                        // Bad Keyword
                        else
                                nlwarning("Unknown keyword '%s' at line %d.", ptr, _Line);
                }
        }

        // If the particle's Id in the sequence is Valid -> create the particleSeq.
        if(_CurParticleSeq.Id >= 0)
        {
                map<uint, CParticleSeq>::iterator itPartSeq = _CurrentSequence.ParticlesSeq.find((uint)_CurParticleSeq.Id);
                // Id already exists.
                if(itPartSeq != _CurrentSequence.ParticlesSeq.end())
                        nlwarning("Particle in Sequence before line %d has the ID %d that already exists -> Particle in the sequence Not Created.", _Line, _CurParticleSeq.Id);
                // Insert the new particle in the sequence.
                else
                        _CurrentSequence.ParticlesSeq.insert(make_pair((uint)_CurParticleSeq.Id, _CurParticleSeq));
        }
        else
                nlwarning("Particle in Sequence before line %d has no ID or a Bad one -> Particle in the sequence Not Created.", _Line);
}// parseSeqParticle //

//-----------------------------------------------
// parseSeqParticleId :
// Parse the current particle's Id in the current sequence.
//-----------------------------------------------
void CSceneParser::parseSeqParticleId()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurParticleSeq.Id = atoi(ptr);
}// parseSeqParticleId //

//-----------------------------------------------
// parseSeqParticleAnims :
// Parse anims used for the current particle in the current sequence.
//-----------------------------------------------
void CSceneParser::parseSeqParticleAnims(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Anims") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CurParticleSeq.Anims.push_back(ptr);
                }
        }
}// parseSeqParticleAnims //

//-----------------------------------------------
// parseSeqActor :
// Parse an actor in a sequence.
//-----------------------------------------------
void CSceneParser::parseSeqActor(ifstream &file, char *buff)
{
        // Reset the current sequence.
        _CurrentActorSeq.reset();

        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Actor") == 0)
                                break;

                        // Actor in Sequence Id.
                        else if(strcmp(ptr, "Id:") == 0)
                                parseSeqActorId();

                        // Actor in Sequence anims.
                        else if(strcmp(ptr, "Anims:") == 0)
                                parseSeqActorAnims(file, buff);

                        // Bad Keyword
                        else
                                nlwarning("Unknown keyword '%s' at line %d.", ptr, _Line);
                }
        }

        // If the actor's Id in the sequence is Valid -> create the actorSeq.
        if(_CurrentActorSeq.Id >= 0)
        {
                map<uint, CActorSeq>::iterator itActSeq = _CurrentSequence.ActorsSeq.find((uint)_CurrentActorSeq.Id);
                // Id already exists.
                if(itActSeq != _CurrentSequence.ActorsSeq.end())
                        nlwarning("Actor in Sequence before line %d has the ID %d that already exists -> Actor in the sequence Not Created.", _Line, _CurrentActorSeq.Id);
                // Insert the new actor.
                else
                        _CurrentSequence.ActorsSeq.insert(make_pair((uint)_CurrentActorSeq.Id, _CurrentActorSeq));
        }
        else
                nlwarning("Actor in Sequence before line %d has no ID or a Bad one -> Actor in the sequence Not Created.", _Line);
}// parseSeqActor //

//-----------------------------------------------
// parseSeqActorId :
// Parse the current actor's Id in the current sequence.
//-----------------------------------------------
void CSceneParser::parseSeqActorId()
{
        char *ptr = strtok(NULL, delimiter);
        if(ptr != NULL)
                _CurrentActorSeq.Id = atoi(ptr);
}// parseSeqActorId //

//-----------------------------------------------
// parseSeqActorAnims :
// Parse anims used for the current actor in the current sequence.
//-----------------------------------------------
void CSceneParser::parseSeqActorAnims(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Anims") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CurrentActorSeq.Anims.push_back(ptr);
                }
        }
}// parseSeqActorAnims //

//-----------------------------------------------
// parseSeqCam :
//  Parse camera in the sequence.
//-----------------------------------------------
void CSceneParser::parseSeqCam(ifstream &file, char *buff)
{
        while(!file.eof())
        {
                // Get next valid line.
                getNextValidLine(file, buff);

                char *ptr = strtok(buff, delimiter);
                if(ptr != NULL)
                {
                        // End of the actor definition.
                        if(strcmp(ptr, "End_Camera") == 0)
                                break;
                        // Meshes Name.
                        else
                                _CurrentSequence.CamAnims.push_back(ptr);
                }
        }
}// parseSeqCam //


////////////////
// INIT AFTER //
//-----------------------------------------------
// initActors :
// Initialize Actors Position and rotation .
//-----------------------------------------------
void CSceneParser::initActors()
{
        if(_IG_Init.empty())
                return;

        // Create the instance group with all start positions and rotations.
        UInstanceGroup *IGInit = UInstanceGroup::createInstanceGroup(_IG_Init);
        if(IGInit)
        {
                int nbInst = IGInit->getNumInstance();
                map<uint, CActor>::iterator itActor;
                for(int i = 0; i < nbInst; ++i )
                {
                        sint id = atoi(IGInit->getInstanceName(i).c_str());
                        itActor = _Actors.find(id);
                        if(itActor != _Actors.end())
                        {
                                CActor &actor = (*itActor).second;
                                actor.Pos = IGInit->getInstancePos(i);
                                actor.Rot = IGInit->getInstanceRot(i);
                        }
                        else
                                nlwarning("CSceneParser::initActors : Actor %d is in the IG \"%s\" but is not in the script.", id, _IG_Init.c_str());
                }

                // Destroy the IG to initialize (all is already backup now).
                delete IGInit;
                IGInit = 0;
        }
        else
                nlwarning("CSceneParser::initActors : Can't create the Instance group to initialize actors.");
}// initActors ///


//////////////
// PLAY SEQ //
//-----------------------------------------------
// apply :
// Initialize the scene with the parameters loaded from the script.
//-----------------------------------------------
void CSceneParser::apply()
{
        // If the scene is already initialized -> reset the scene.
        if(_Apply)
        {
                reset();
                return;
        }

        // Create a play list manager for the scene.
        _PlayListManager = Scene->createPlayListManager();

        // Initialize the Camera and reset it the second time.
        applyCamera();

        // Initialize IG for the scenery (IG present from start to end like trees or torch.
        applyIG();

        // Initialize Particles.
        applyParticles();

        // Initialize Actors.
        applyActors();

        // Scene already aplly now.
        _Apply = true;
}// apply //

//-----------------------------------------------
// reset :
// Reset the scene.
//-----------------------------------------------
void CSceneParser::reset()
{
        // Camera in scene mode.
        UserControls.mode(CUserControls::InterfaceMode);

        // Reset all particles.
        resetParticles();

        // Reset all actors.
        resetActors();
}// reset //

//-----------------------------------------------
// resetParticles :
// Reset all particles.
//-----------------------------------------------
void CSceneParser::resetParticles()
{
        map<uint, CParticle>::iterator itPart = _Particles.begin();
        for(itPart = _Particles.begin(); itPart != _Particles.end(); ++itPart)
        {
                // Get a reference on the particule.
                CParticle &particle = (*itPart).second;

                // Check if the IG of particles is not already in the scene.
                if(particle.IGPtr && _IGInScene.find(particle.IGPtr) != _IGInScene.end())
                {
                        // Reset the playlist.
                        particle.PlayList->resetAllChannels();

                        // Remove from the set with all particle in the scene.
                        _IGInScene.erase(particle.IGPtr);
                        // Remove particles from scene.
                        particle.IGPtr->removeFromScene(*Scene);
                        Scene->deleteInstanceGroup (particle.IGPtr);

                        // Load the IG of the particle.
                        particle.IGPtr = 0;

                        try
                        {
                                particle.IGPtr = UInstanceGroup::createInstanceGroup((*itPart).second.IG);
                        }
                        catch(Exception &e){nlwarning("CSceneParser::resetParticles : %s", e.what());}
                }
        }
}// resetParticles //

//-----------------------------------------------
// resetActors :
// Reset all actors.
//-----------------------------------------------
void CSceneParser::resetActors()
{
        // Create new entities from actors
        map<uint, CActor>::iterator itActor;
        for(itActor = _Actors.begin(); itActor != _Actors.end(); ++itActor)
        {
                // Get a reference on the actor.
                CActor &actor = (*itActor).second;

                // Get the Sid.
                Sid entityId(Sid::npc, (uint64)actor.Id);

                // Find the actor.
                CEntityCL *entity = getEntity(entityId);
                if(entity)
                {
                        // Position the entity.
                        entity->pacsPos(actor.Pos);

                        // Position the skeleton at the same position as the entity.
                        if(entity->skeleton())
                        {
                                entity->skeleton()->setPos(actor.Pos);
                                entity->skeleton()->setRotQuat(actor.Rot);
                        }
                }

                // Reset entity animations.
                resetAnimatedSceneObject(entityId);
        }
}// resetActors //


//-----------------------------------------------
// applyParticles :
// Initialize the scene with the parameters loaded from the script for particles.
//-----------------------------------------------
void CSceneParser::applyParticles()
{
        map<uint, CParticle>::iterator itPart = _Particles.begin();
        for(itPart = _Particles.begin(); itPart != _Particles.end(); ++itPart)
        {
                // Get a reference on the particule.
                CParticle &particle = (*itPart).second;

                // Create the animation set for the particule.
                particle.AnimationSet = Driver->createAnimationSet();

                // Add animations to the animation set.
                list<string>::iterator itPartAnim;
                for(itPartAnim = particle.Anims.begin(); itPartAnim != particle.Anims.end(); ++itPartAnim)
                {
                        uint idAnim = UAnimationSet::NotFound;
                        try
                        {
                                idAnim = particle.AnimationSet->addAnimation((*itPartAnim + string(".anim")).c_str(), (*itPartAnim).c_str());
                        }
                        catch(Exception &e) {nlwarning("%s", e.what());}

                        if(idAnim != UAnimationSet::NotFound)
                        {
                                particle.AnimToId.insert(make_pair((*itPartAnim).c_str(), idAnim));
                        }
                        else
                                nlwarning("CSceneParser::applyParticles : Anim %s cannot be add in the animation set", (*itPartAnim).c_str());
                }

                // Build animation set
                particle.AnimationSet->build();

                // Create playlist.
                particle.PlayList = _PlayListManager->createPlayList(particle.AnimationSet);
                if(particle.PlayList)
                {
                        // Load the IG of the particle.
                        particle.IGPtr = 0;
                        try
                        {
                                particle.IGPtr = UInstanceGroup::createInstanceGroup((*itPart).second.IG);
                        }
                        catch(Exception &e) {nlwarning("%s", e.what());}

                        if(particle.IGPtr)
                        {
                                // Get the position of Instances in IG.
                                for(uint i = 0; i < particle.IGPtr->getNumInstance(); ++i )
                                        particle.IGPos.push_back(particle.IGPtr->getInstancePos(i));
                        }
                }
        }
}// applyParticles //

//-----------------------------------------------
// applyCamera :
// Initialize the Camera and reset it the second time.
//-----------------------------------------------
void CSceneParser::applyCamera()
{
        // Create the animation set for the camera if not already done.
        _AnimationSet = Driver->createAnimationSet();
        if(_AnimationSet)
        {
                list<string>::iterator itCamAnims;
                for(itCamAnims = _CamAnims.begin(); itCamAnims != _CamAnims.end(); ++itCamAnims)
                {
                        uint idAnim = UAnimationSet::NotFound;
                        try
                        {
                                idAnim = _AnimationSet->addAnimation((*itCamAnims + string(".anim")).c_str(), (*itCamAnims).c_str());
                        }
                        catch(Exception &e) {nlwarning("%s", e.what());}

                        if(idAnim != UAnimationSet::NotFound)
                                _AnimCamToId.insert(make_pair((*itCamAnims).c_str(), idAnim));
                        else
                                nlwarning("CSceneParser::apply : Camera Anim %s cannot be add in the animation set", (*itCamAnims).c_str());
                }

                // Build animation set
                _AnimationSet->build();

                // create playlist
                _PlayList = _PlayListManager->createPlayList( _AnimationSet );
        }
        else
                nlwarning("CSceneParser::apply : AnimationSet cannot be created.");
}// applyCamera //

//-----------------------------------------------
// applyIG :
// Initialize IG for the scenery (IG present from start to end like trees or torch.
//-----------------------------------------------
void CSceneParser::applyIG()
{
        // Load Instances Groups for the scene.
        for(list<string>::iterator itIG = _IG.begin(); itIG != _IG.end(); ++itIG)
        {
                UInstanceGroup *IGTemp = 0;
                try
                {
                        IGTemp = UInstanceGroup::createInstanceGroup(*itIG);
                }
                catch(Exception &e) {nlwarning("CSceneParser::applyIG : %s", e.what());}

                // Add Instance Group in the scene.
                if(IGTemp)
                        IGTemp->addToScene(*Scene, Driver);
        }
}// applyIG //

//-----------------------------------------------
// applyActors :
// Initialize actors.
//-----------------------------------------------
void CSceneParser::applyActors()
{
        // Create new entities from actors
        map<uint, CActor>::iterator itActor;
        for(itActor = _Actors.begin(); itActor != _Actors.end(); ++itActor)
        {
                // Get a reference on the actor.
                CActor &actor = (*itActor).second;

                // Create the entity Sid.
                Sid entityId(Sid::npc, (uint64)actor.Id);

                // Create the entity type.
                CTypeEntity typeEntity;
                typeEntity.TypeInfo.TypeEntity  = CTypeEntity::npc;
                typeEntity.TypeInfo.Kind                = CTypeEntity::zorai;
                typeEntity.TypeInfo.Age                 = CTypeEntity::adult;
                typeEntity.TypeInfo.Sex                 = CTypeEntity::male;

                // Create the entity.
                CEntityCL *entityTmp = createEntity(entityId, typeEntity);
                if(entityTmp)
                {
                        // Get a reference on the entity.
                        CEntityCL &entity = *entityTmp;

                        // True if the entity fly.
                        entity.flyer(actor.Fly);

                        // Set the name of the entity
                        entity.name(actor.Name);
                        // Time for the current frame.
                        entity.time(T1);
                        // Set the entity position.
                        entity.pacsPos(actor.Pos);
                        // Set the Front.
                        CMatrix m;
                        m.identity();
                        m.setRot(actor.Rot);
                        entity.front((m * CVector::J).normed());
                        // Set the direction like the front.
                        entity.dir(entity.front());
                        // Set the vector UP.
                        entity.up(CVector(0.f,0.f,1.f));

                        // Assign a skeleton.
                        entity.skeleton(actor.Skeleton);

                        // Position the entity.
                        entity.pacsPos(actor.Pos);

                        // Position the skeleton at the same position as the entity.
                        if(entity.skeleton())
                        {
                                entity.skeleton()->setPos(actor.Pos);
                                entity.skeleton()->setRotQuat(actor.Rot);
                        }

                        // Assign meshes used for the entity.
                        uint count = 0;
                        list<string>::iterator itMeshes;
                        for(itMeshes = actor.Meshes.begin(); itMeshes != actor.Meshes.end(); ++itMeshes)
                        {
                                // If there are too many meshes.
                                if(count >= (uint)CEntityCL::NB_SLOT)
                                {
                                        nlwarning("CSceneParser::applyActors : Too many meshes for Actor %d.", actor.Id);
                                        break;
                                }

                                entity.slot((CEntityCL::ESlots)count, *itMeshes);
                                ++count;
                        }

                        // Create the playlist
                        addEntityClAnimatedSceneObject(entityId, actor.Anims);
                }
                else
                        nlwarning("CSceneParser::applyActors : Entity %d Not created", actor.Id);
        }
}// applyActors //


//-----------------------------------------------
// playSeq :
// Play the sequence with the ID 'seq'.
//-----------------------------------------------
void CSceneParser::playSeq(uint seq, double timeInSec)
{
        // If the scene is not initialized -> return.
        if(!_Apply)
                return;

        // Camera in scene mode.
        UserControls.mode(CUserControls::SceneMode);

        _TimeStart = timeInSec;

        map<uint, CSequence>::iterator itSeq = _Sequences.find(seq);
        if(itSeq != _Sequences.end())
        {
                // Get a reference on the sequence.
                CSequence &sequence = (*itSeq).second;

                // Log the time used for the sequence.
                nlwarning("Sequence: %d, Time: %f", seq, timeInSec);

                // Camera in the sequence.
                if(!sequence.CamAnims.empty())
                {
                        if(_PlayList)
                        {
                                map<string, uint>::iterator itAnimCamId;
                                for(itAnimCamId = _AnimCamToId.begin(); itAnimCamId != _AnimCamToId.end(); ++itAnimCamId)
                                {
                                        _PlayList->setTimeOrigin(0, timeInSec);
                                        _PlayList->setAnimation(0, (*itAnimCamId).second);
                                }
                        }
                }

                // Particles in the sequence.
                map<uint, CParticleSeq>::iterator itPartSeq;
                for(itPartSeq = sequence.ParticlesSeq.begin(); itPartSeq != sequence.ParticlesSeq.end(); ++itPartSeq)
                {
                        CParticleSeq &particleSeq = (*itPartSeq).second;
                        map<uint, CParticle>::iterator itPart = _Particles.find(particleSeq.Id);
                        if(itPart != _Particles.end())
                        {
                                // Get a reference on the particle.
                                CParticle &particle = (*itPart).second;
                                // Check if the IG has been created.
                                if(particle.IGPtr)
                                {
                                        // Check if the IG of particles is not already in the scene.
                                        if(_IGInScene.find(particle.IGPtr) == _IGInScene.end())
                                        {
                                                // Insert IG in the set of IG in the scene.
                                                _IGInScene.insert(particle.IGPtr);
                                                // Cluster.
                                                if(IGCity.find(particle.Cluster) == IGCity.end())
                                                        Scene->setToGlobalInstanceGroup(particle.IGPtr);
                                                else
                                                        particle.IGPtr->setClusterSystem(IGCity[particle.Cluster]);
                                                // Add particles to the scene.
                                                particle.IGPtr->addToScene(*Scene, Driver);
                                                // Unfreeze the IG.
                                                particle.IGPtr->unfreezeHRC();

                                                //  Register all instances in the IG to a playlist.
                                                for(uint i = 0; i < particle.IGPtr->getNumInstance(); ++i )
                                                {
                                                        std::string iName = particle.IGPtr->getInstanceName( i );
                                                        UInstance  instance = particle.IGPtr->getByName( iName );
                                                        particle.PlayList->registerTransform(instance);
                                                        particle.PlayList->registerTransform(instance, (iName + ".").c_str());
                                                }
                                        }

                                        // Start the particle animation.
                                        map<string, uint>::iterator itAnimId;
                                        for(itAnimId = particle.AnimToId.begin(); itAnimId != particle.AnimToId.end(); ++itAnimId)
                                        {
                                                particle.PlayList->setTimeOrigin(0, timeInSec);
                                                particle.PlayList->setAnimation(0, (*itAnimId).second);
                                        }
                                }
                        }
                }

                // Actors in the sequence.
                map<uint, CActorSeq>::iterator itActSeq;
                for(itActSeq = sequence.ActorsSeq.begin(); itActSeq != sequence.ActorsSeq.end(); ++itActSeq)
                {
                        CActorSeq &actorSeq = (*itActSeq).second;
                        updateAnimationSequence(Sid(Sid::npc, (uint64)actorSeq.Id), actorSeq.Anims, 0 );
                }
        }
}// playSeq //


//-----------------------------------------------
// update :
// Update the scene.
//-----------------------------------------------
void CSceneParser::update(double timeInSec)
{
        // Nothing to update if the scene is not applied.
        if(!_Apply)
                return;

        // Update the scene currently playing.
        updateScene(timeInSec);

        // Update particles.
        updateParticles(timeInSec);

        // Animate the camera.
        updateCamera(timeInSec);

        // Update particle anims.
        if(_PlayListManager)
                _PlayListManager->animate(timeInSec);

        // Update actor position (for actor on another actor).
        updateActors();
}// update //

//-----------------------------------------------
// updateCamera :
// Update the camera (position, target, roll, fov)
//-----------------------------------------------
void CSceneParser::updateCamera(double timeInSec)
{
        // If there is a play list for the camera.
        if(_PlayList)
        {
                // Get the Id of the animation in the slot 0.
                uint idAnim = _PlayList->getAnimation(0);
                if(idAnim != UPlayList::empty)
                {
                        UAnimation *animation = _AnimationSet->getAnimation(idAnim);
                        if(animation)
                        {
                                // Get Camera information from the animation (Pos, Target, Roll).
                                UTrack* trackRollCam    = animation->getTrackByName("Camera.roll");
                                UTrack* trackFovCam             = animation->getTrackByName("Camera.fov");
                                UTrack* trackPosCam             = animation->getTrackByName("Camera.PathPos");
                                UTrack* trackPosTarget  = animation->getTrackByName("Camera.Target.PathPos");
                                if(trackPosCam && trackPosTarget)
                                {
                                        float rollCam = 0.f;
                                        CVector posCam;
                                        CVector posTarget;
                                        float difTime = (float)(timeInSec-_TimeStart);

                                        if(trackRollCam)
                                                trackRollCam->interpolate(difTime, rollCam);
                                        trackPosCam->interpolate(difTime, posCam);
                                        trackPosTarget->interpolate(difTime, posTarget);

                                        // Update camera transformations.
                                        UCamera cam = Scene->getCam();
                                        if(cam)
                                        {
                                                cam->setTransformMode(UTransformable::RotQuat);
                                                cam->lookAt(posCam, posTarget, rollCam);
                                                if(trackFovCam)
                                                {
                                                        float fov;
                                                        trackFovCam->interpolate(difTime, fov);
                                                        CFrustum        fr= cam->getFrustum();
                                                        // change only the fov
                                                        cam->setPerspective(fov, fr.getAspectRatio(), fr.Near, fr.Far);
                                                }
                                        }

                                        // Update camera transformations for the Root.
                                        cam = SceneRoot->getCam();
                                        if(cam)
                                        {
                                                cam->setTransformMode(UTransformable::RotQuat);
                                                cam->lookAt(posCam, posTarget, rollCam);
                                                if(trackFovCam)
                                                {
                                                        float fov;
                                                        trackFovCam->interpolate(difTime, fov);
                                                        CFrustum        fr= cam->getFrustum();
                                                        // change only the fov
                                                        cam->setPerspective(fov, fr.getAspectRatio(), fr.Near, fr.Far);
                                                }
                                        }
                                }
                        }
                }
        }
}// updateCamera //

//-----------------------------------------------
// updateActors :
// Update Actors.
//-----------------------------------------------
void CSceneParser::updateActors()
{
        // All actors in the scene.
        for(map<uint, CActor>::iterator itActor = _Actors.begin(); itActor != _Actors.end(); ++itActor)
        {
                // Get a reference on the actor.
                CActor &actor = (*itActor).second;

                // If there is no actor to follow -> next actor.
                if(actor.Actor < 0)
                        continue;

                // Get the entity pointer.
                CEntityCL *entity = getEntity(Sid(Sid::npc, (uint64)actor.Id));
                if(!entity)
                {
                        nlwarning("CSceneParser::updateActors : Cannot get the actor %d.", actor.Id);
                        continue;
                }

                // Get the target entity pointer.
                CEntityCL *entityTarget = getEntity(Sid(Sid::npc, (uint64)actor.Actor));
                if(!entityTarget)
                {
                        nlwarning("CSceneParser::updateActors : Cannot get the targeted actor %d.", actor.Actor);
                        continue;
                }

                // Changes the entity position.
                entity->pacsPos(entityTarget->pos());
        }
}// updateActors //

//-----------------------------------------------
// updateParticles :
// Update particles.
//-----------------------------------------------
void CSceneParser::updateParticles(double timeInSec)
{
        for(map<uint, CParticle>::iterator itPart = _Particles.begin(); itPart != _Particles.end(); ++itPart)
        {
                // Get a reference on the particule.
                CParticle &particle = (*itPart).second;

                // If the IG pointer is null -> Next particle.
                if(!(particle.IGPtr))
                        continue;

                // If the play list is NULL -> Next particle
                if(!(particle.PlayList))
                        continue;

                // Get the Id of the animation in the slot 0 -> if empty -> Next particle.
                uint idAnim = particle.PlayList->getAnimation(0);
                if(idAnim == UPlayList::empty)
                        continue;

                // Get the animation pointer.
                UAnimation *animation = particle.AnimationSet->getAnimation(idAnim);
                if(!animation)
                        continue;

                // Get the time difference.
                float difTime = (float)(timeInSec-_TimeStart);

                // Particle do not follow anything.
                if(particle.Actor < 0)
                {
                        updateParticlesNoActor(difTime, particle, *animation);
                }
                // Particle follow an actor.
                else
                {
                        updateParticlesActor(difTime, particle, *animation);
                }
        }
}// updateParticles //

//-----------------------------------------------
// updateParticlesNoActor :
//
//-----------------------------------------------
void CSceneParser::updateParticlesNoActor(float difTime, CParticle &particle, UAnimation &animation)
{
        // Animate all instances.
        for(uint i = 0; i < particle.IGPtr->getNumInstance(); ++i )
        {
                std::string iName = particle.IGPtr->getInstanceName(i);
                UInstance instance = particle.IGPtr->getByName(iName);

                if(!instance)
                        continue;

                instance->setTransformMode(UTransformable::RotQuat);

                // If the animation has no track of position.
                UTrack* trackPos = animation.getTrackByName("PathPos");
                if(!trackPos)
                        trackPos = animation.getTrackByName(string(iName + "." + "PathPos").c_str());
                if(trackPos)
                {
                        CVector pos;
                        trackPos->interpolate(difTime, pos);
                        instance->setPos(pos);
                }

                // If the animation has no track of rotation.
                UTrack* trackRot = animation.getTrackByName("PathRotQuat");
                if(!trackRot)
                        trackRot = animation.getTrackByName(string(iName + "." + "PathRotQuat").c_str());
                if(trackRot)
                {
                        CQuat rot;
                        if(trackRot->interpolate(difTime, rot))
                                instance->setRotQuat(rot);
                        else
                                nlwarning("CSceneParser::updateParticles : Not a Quat!");
                }
        }
}// updateParticlesNoActor //


//-----------------------------------------------
// updateParticlesActor :
//
//-----------------------------------------------
void CSceneParser::updateParticlesActor(float difTime, CParticle &particle, UAnimation &animation)
{
        // Get the entity pointer.
        CEntityCL *entity = getEntity(Sid(Sid::npc, (uint64)particle.Actor));
        if(!entity)
        {
                nlwarning("CSceneParser::updateParticlesActor : cannot get the actor %d.", (uint64)particle.Actor);
                return;
        }

        // If the entity has no skeleton -> Next particle.
        if(!entity->skeleton())
        {
                nlwarning("The particle follow an entity %d without a skeleton.", (uint64)particle.Actor);
                return;
        }

        // Matrix 90 degrees
        CMatrix m90;
        m90.identity();
        m90.rotateZ((float)(Pi/2.0));

        // Matrix of the entity.
        CMatrix mChar = entity->skeleton()->getMatrix();
        mChar.setPos(entity->pos());

        // Animate all instances.
        for(uint i = 0; i < particle.IGPtr->getNumInstance(); ++i )
        {
                std::string iName = particle.IGPtr->getInstanceName(i);
                UInstance instance = particle.IGPtr->getByName(iName);

                if(!instance)
                        continue;

                instance->setTransformMode(UTransformable::RotQuat);

                CMatrix mAnim;
                mAnim.identity();
                // If the animation has no track of position.
                UTrack* trackPos = animation.getTrackByName("PathPos");
                if(!trackPos)
                        trackPos = animation.getTrackByName(string(iName + "." + "PathPos").c_str());
                if(trackPos)
                {
                        CVector pos;
                        trackPos->interpolate(difTime, pos);
                        mAnim.setPos(pos);
                }

                // If the animation has no track of rotation.
                UTrack* trackRot = animation.getTrackByName("PathRotQuat");
                if(!trackRot)
                        trackRot = animation.getTrackByName(string(iName + "." + "PathRotQuat").c_str());
                if(trackRot)
                {
                        CQuat rot;
                        trackPos->interpolate(difTime, rot);
                        mAnim.setRot(rot);
                }

                CMatrix mFinal = mChar * m90 * mAnim;
                instance->setPos(mFinal.getPos());
                instance->setRotQuat(mFinal.getRot());
        }
}// updateParticlesActor //


//-----------------------------------------------
// loadScene :
// Load a scene from a file and put it in memory.
// \param filename : filename for the file that contains the scene.
// \warning This function clear the old scene.
//-----------------------------------------------
void CSceneParser::loadScene(const string &filename)
{
        // Look for the file -> nlwarning and return if sceneFile is empty.
        string sceneFile = CPath::lookup(filename, false);
        if(sceneFile.empty())
        {
                nlwarning("CSceneParser::loadScene : Can't find file \"%s\".", filename.c_str());
                return;
        }

        // Open the file.
        ifstream file(sceneFile.c_str(), ios::in);
        if(file.is_open())
        {
                // ...
                char tmpBuff[MAX_LINE_SIZE];

                // While the end of the file is not reached -> parse the script.
                while(!file.eof())
                {
                        // Get next valid line.
                        getNextValidLine(file, tmpBuff);

                        pair<sint, double> seq;
                        // ...
                        char *ptr = strtok(tmpBuff, delimiter);
                        if(ptr != NULL)
                        {
                                seq.first = atoi(ptr);
                                ptr = strtok(NULL, delimiter);
                                if(ptr != NULL)
                                {
                                        NLMISC::fromString(ptr, seq.second);
                                        _Scene.push_back(seq);
                                }
                        }
                }

                // Close the File.
                file.close();
        }
        else
        {
                nlwarning("CSceneParser::loadScene : File \"%s\" can't be open.", sceneFile.c_str());
                return;
        }
}// loadScene //

//-----------------------------------------------
// playScene :
// Play a scene in memory.
// \param timeInSec : current time in second.
//-----------------------------------------------
void CSceneParser::playScene(double timeInSec)
{
        // Initialize the Iterator for the scene.
        _ItScene = _Scene.begin();
        // Initialize the time for the scene.
        _SceneStart = timeInSec;

        // Initialize or Reset the scene.
        apply();

        // Play the first sequence to play for this scene.
        updateScene(timeInSec);
}// playScene //

//-----------------------------------------------
// updateScene :
// Update the scene currently playing.
// \param timeInSec : current time in second.
//-----------------------------------------------
void CSceneParser::updateScene(double timeInSec)
{
        // If there are still sequences in the scene.
        if(_ItScene != _Scene.end())
        {
                double time = timeInSec-_SceneStart;
                if((*_ItScene).second <= time)
                {
                        // If the scene is finish -> Stop it.
                        if((*_ItScene).first < 0)
                        {
                                stopScene();
                        }
                        else
                        {
                                // Play the sequence.
                                playSeq((*_ItScene).first, timeInSec);

                                // Next sequence.
                                _ItScene++;
                        }
                }
        }
}// updateScene //

//-----------------------------------------------
// stopScene :
// Stop the scene currently playing.
//-----------------------------------------------
void CSceneParser::stopScene()
{
        _ItScene = _Scene.end();
        _SceneStart = -1.f;
}// stopScene //

//-----------------------------------------------
// Function to know if there is a scene currently playing.
// \return bool : 'true' if there is a scene currently playing.
//-----------------------------------------------
bool CSceneParser::isScenePlaying()
{
        return (_ItScene != _Scene.end());
}// isScenePlaying //