khanat-code-old/code/ryzom/client/src/scene_parser.h

// 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/>.




#ifndef CL_SCENE_PARSER_H
#define CL_SCENE_PARSER_H


/////////////
// INCLUDE //
/////////////
// Misc
#include "nel/misc/types_nl.h"
#include "nel/misc/vector.h"
#include "nel/misc/quat.h"
// 3D Interface.
#include "nel/3d/u_animation_set.h"
#include "nel/3d/u_play_list_manager.h"
#include "nel/3d/u_play_list.h"
#include "nel/3d/u_instance_group.h"
// Std.
#include <string>
#include <fstream>
#include <list>
#include <vector>
#include <map>
#include <set>


///////////
// USING //
///////////
using NLMISC::CVector;
using NLMISC::CQuat;
using NL3D::UPlayListManager;
using NL3D::UAnimationSet;
using NL3D::UAnimation;
using NL3D::UPlayList;
using NL3D::UInstanceGroup;
/*using std::string;
using std::ifstream;
using std::list;
using std::vector;
using std::map;
using std::set;
using std::pair;*/


///////////
// CLASS //
///////////
/**
 * Class to parse a scene.
 * \author Guillaume PUZIN
 * \author Nevrax France
 * \date 2001
 */
class CSceneParser
{
private:
	static const uint MAX_LINE_SIZE;
	static const char *delimiter;

	/// Parse the file.
	void parse(ifstream &file);

	/// Skip empty lines and comment lines.
	void getNextValidLine(ifstream &file, char *buff);

	/// Day/Night.
	void parseTime();
	/// Parse the list of IG to load for the scene.
	void parseIG(ifstream &file, char *buff);
	/// Get the name of the IG to initialize entities.
	void parseIGInit();

	/// Parse Particle.
	void parseParticle(ifstream &file, char *buff);
	/// Parse Particle's Id.
	void parseParticleId();
	/// Parse Particle's IG.
	void parseParticleIG();
	/// Parse Particle's Cluster
	void parseParticleCluster();
	/// Parse Particle's Actor.
	void parseParticleActor();
	/// Parse Particle's anims.
	void parseParticleAnims(ifstream &file, char *buff);

	/// Parse an actor.
	void parseActor(ifstream &file, char *buff);
	/// Parse the current actor Id.
	void parseId();
	/// Parse the current actor Name.
	void parseName();
	/// Is the Actor a flyer.
	void parseFly();
	/// Parse Actor's Actor.
	void parseActorActor();
	/// Parse the current actor Skeleton Name.
	void parseSkel();
	/// Parse meshes used for the current actor.
	void parseMeshes(ifstream &file, char *buff);
	/// Parse anims used for the current actor.
	void parseAnims(ifstream &file, char *buff);

	/// Parse all anims used for the camera in all sequence.
	void parseCamAnims(ifstream &file, char *buff);

	/// Parse a sequence.
	void parseSequence(ifstream &file, char *buff);
	/// Parse the current sequence Id.
	void parseSeqId();
	/// Parse particle in the sequence.
	void parseSeqParticle(ifstream &file, char *buff);
	/// Parse the current particle's Id in the current sequence.
	void parseSeqParticleId();
	/// Parse anims used for the current particle in the current sequence.
	void parseSeqParticleAnims(ifstream &file, char *buff);
	/// Parse an actor in a sequence.
	void parseSeqActor(ifstream &file, char *buff);
	/// Parse the current actor's Id in the current sequence.
	void parseSeqActorId();
	/// Parse anims used for the current actor in the current sequence.
	void parseSeqActorAnims(ifstream &file, char *buff);
	/// Parse camera in the sequence.
	void parseSeqCam(ifstream &file, char *buff);

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

	/// Reset the scene.
	void reset();
	/// Reset all particles.
	void resetParticles();
	/// Reset all actors.
	void resetActors();

	/// Initialize the Camera and reset it the second time.
	void applyCamera();
	/// Initialize IG for the scenery (IG present from start to end like trees or torch.
	void applyIG();
	/// Initialize the scene with the parameters loaded from the script for particles.
	void applyParticles();
	/// Initialize actors.
	void applyActors();

protected:
	bool	_Apply;
	sint	_Line;
	bool	_Day;
	string	_IG_Init;
	/// List of IG to load for the scene.
	list<string>			_IG;
	double		_TimeStart;
	double	_FrameRate;

	/// Class to stock parameters for a particle (system).
	class CParticle
	{
	public:
		sint				Id;
		string				IG;
		string				Cluster;
		sint				Actor;
		list<string>		Anims;

		UInstanceGroup		*IGPtr;
		vector<CVector>		IGPos;

		map<string, uint>	AnimToId;
		UAnimationSet		*AnimationSet;
		UPlayList			*PlayList;

		CParticle()
		{
			AnimationSet = 0;
			PlayList = 0;
		}

		void reset()
		{
			Id = -1;
			Actor = -1;
			Anims.clear();
			AnimationSet = 0;
			PlayList = 0;
			AnimToId.clear();
		}
	};

	/// Class to stock parameters for an actor.
	class CActor
	{
	public:
		sint			Id;
		string			Name;
		bool			Fly;
		string			Skeleton;
		list<string>	Meshes;
		list<string>	Anims;
		CVector			Pos;
		CQuat			Rot;
		sint			Actor;

		void reset()
		{
			Id = -1;
			Actor = -1;
			Fly = false;
			Meshes.clear();
			Anims.clear();
		}
	};

	/// Class to stock parameters for an actor in a sequence.
	class CParticleSeq
	{
	public:
		sint			Id;
		list<string>	Anims;

		void reset()
		{
			Id = -1;
			Anims.clear();
		}
	};

	/// Class to stock parameters for an actor in a sequence.
	class CActorSeq
	{
	public:
		sint			Id;
		list<string>	Anims;

		void reset()
		{
			Id = -1;
			Anims.clear();
		}
	};

	/// Class to stock parameters for a sequence.
	class CSequence
	{
	public:
		sint					Id;
		map<uint, CParticleSeq>	ParticlesSeq;
		map<uint, CActorSeq>	ActorsSeq;
		list<string>			CamAnims;

		void reset()
		{
			Id = -1;
			ActorsSeq.clear();
		}
	};

	/// ...
	list<string>			_CamAnims;
	/// Particle with the parse in progress.
	CParticle				_CurrentParticle;
	/// All particles in the scene.
	map<uint, CParticle>	_Particles;
	/// Actor with the parse in progress.
	CActor					_CurrentActor;
	/// All actors in the scene.
	map<uint, CActor>		_Actors;
	/// ...
	CParticleSeq			_CurParticleSeq;
	/// ...
	CActorSeq				_CurrentActorSeq;
	/// ...
	CSequence				_CurrentSequence;
	/// All Sequences in the scene.
	map<uint, CSequence>	_Sequences;

	/// ...
	UPlayListManager		*_PlayListManager;
	UAnimationSet			*_AnimationSet;
	UPlayList				*_PlayList;
	map<string, uint>		_AnimCamToId;

	set<UInstanceGroup *>	_IGInScene;

	// Scene.
	typedef list<pair<sint, double> > TScene;
	TScene					_Scene;
	TScene::iterator		_ItScene;
	double					_SceneStart;


	/// Update the camera (position, target, roll, fov).
	void updateCamera(double timeInSec);
	/// Update actor position (for actor on another actor).
	void updateActors();
	/// Update particles.
	void updateParticles(double timeInSec);
	void updateParticlesNoActor(float difTime, CParticle &particle, UAnimation &animation);
	void updateParticlesActor(float difTime, CParticle &particle, UAnimation &animation);

public:
	/// Constructor
	CSceneParser();

	inline bool Time() {return _Day;}

	/// Load the file with the scene.
	void load(const string &filename);

	/// Initialize the scene with the parameters loaded from the script.
	void apply();

	///
	void update(double timeInSec);

	/// Play the sequence with the ID 'seq'.
	void playSeq(uint seq, double timeInSec);

	inline double frameRate() {return _FrameRate;}
	inline void frameRate(double fr) {_FrameRate = fr;}

	/** \name SCENE
	 * Functions to manage a scene.
	 */
	//@{
	/**
	 * 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 loadScene(const string &filename);
	/**
	 * Play a scene in memory.
	 * \param timeInSec : current time in second.
	 */
	void playScene(double timeInSec);
	/**
	 * Update the scene currently playing.
	 * \param timeInSec : current time in second.
	 */
	void updateScene(double timeInSec);
	/**
	 * Stop the scene currently playing.
	 */
	void stopScene();
	/**
	 * Function to know if there is a scene currently playing.
	 * \return bool : 'true' if there is a scene currently playing.
	 */
	bool isScenePlaying();
	//@}
};


#endif // CL_SCENE_PARSER_H

/* End of scene_parser.h */