mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-29 20:30:54 +00:00
1779 lines
46 KiB
C++
1779 lines
46 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)
|
||
|
|
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 //
|