mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-05 01:34:50 +00:00
1778 lines
47 KiB
C++
1778 lines
47 KiB
C++
// 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)
|
||
_FrameRate = atof(ptr);
|
||
}
|
||
|
||
// 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 informations 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<39>
|
||
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)
|
||
{
|
||
seq.second = atof(ptr);
|
||
_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 //
|