khanat-opennel-code/code/nel/tools/3d/object_viewer_qt/src/particle_node.h

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// 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 PARTICLE_NODE_H
#define PARTICLE_NODE_H

// STL includes
#include <string>
#include <vector>

// NeL includes
#include "nel/misc/smart_ptr.h"
#include "nel/misc/stream.h"
#include <nel/misc/path.h>
#include "nel/3d/skeleton_model.h"

// Projects includes
#include "ps_initial_pos.h"


namespace NL3D {
	class CParticleSystem;
	class CParticleSystemModel;
	class CShapeBank;
}

namespace NLQT {
  
class CParticleWorkspace;

/**
@class CWorkspaceNode
@author Nicolas Vizerie
@author Nevrax France
@date 2004
@brief A node in the workspace particles system editor.
@details Contains NeL system of particles and allows them to perform the following operations:
- Creating a new empty particle system (createEmptyPS()).
- Loading and saving the existing system of particles.
- Linking / unlinking of the system of particles to any bone of the skeleton model.
- Operations with the name and directory location of the particles system file.
- Has a flag indicating if the particles system changed or not (intended for the editor) 
*/
class CWorkspaceNode : public NLMISC::CRefCount
{
public:
	void init(CParticleWorkspace *ws);
	
	void setRelativePath(const std::string &relativePath);
	
	const std::string &getRelativePath() const { return _RelativePath; }
	
	std::string getFullPath() const;
	
	std::string getFilename() const { return NLMISC::CFile::getFilename(_RelativePath); }
	
	/// Serial node information into workspace stream. This does not save the particle system shape, only a reference to its file
	void serial(NLMISC::IStream &f);
	
	/// Save the particle system target file
	void savePS() throw(NLMISC::EStream);
	
	/// Save particle system with an arbitrary filename
	void savePSAs(const std::string &fullPath) throw(NLMISC::EStream);
	
	/// put back in the unloaded state
	void unload();
	
	/// Load the particle system target file
	/// @return true if loading succeed (false means that loading was ok, but this is not a particle system). Other cases throw an exception.
	bool loadPS() throw(NLMISC::EStream);
	
	/// Create an empty particle system
	void createEmptyPS();
	
	/// Helper flag to know if a ps has been modified
	/// @{
	bool isModified() const { return _Modified; }
	void setModified(bool modified);
	/// @}
	NL3D::CParticleSystem	   *getPSPointer() const { return _PS; }
	NL3D::CParticleSystemModel *getPSModel() const { return _PSM; }
	
	/// See if this node ps has been loaded
	bool isLoaded() const { return _PS != NULL; }
	
	/// Get the workspace in which this node is inserted
	CParticleWorkspace         *getWorkspace() const { return _WS; }
	
	/// Memorize current position of object in the system. Useful to play the system because instances can be created / deleted
	void memorizeState();
	
	/// Restore state previously memorize. Is usually called when the user stops a particle system
	void restoreState();
	
	/// Test if state is currenlty memorized
	bool isStateMemorized() const;
	
	/// For edition : If the state of the system has been memorized, keep it on par with the system when it is modified
	void removeLocated(NL3D::CPSLocated *loc);
	
	/// For edition : If the state of the system has been memorized, keep it on par with the system when it is modified	
	void removeLocatedBindable(NL3D::CPSLocatedBindable *lb);
	
	/// Returns the skeleton to which the ps is currently sticked
	NL3D::CSkeletonModel *getParentSkel() const { return _ParentSkel; }
	
	const std::string &getParentSkelName() const { return _ParentSkelName; }
	
	const std::string &getParentBoneName() const { return _ParentBoneName; }
	
	std::string getTriggerAnim() { return _TriggerAnim; }
	
	void setTriggerAnim(const std::string &anim);
	
private:
	std::string				_TriggerAnim;
	NL3D::CParticleSystem			*_PS;
	NL3D::CParticleSystemModel		*_PSM;
	
	// Keep a shape bank per node because we want the whole path to identify the ps, not just its filename
	// (shape bank keeps the filename only)
	NL3D::CShapeBank			*_ShapeBank;
	
	// Relative path from which the ps was inserted
	// relative path is also a unique identifier for this ps in the workspace
	std::string				_RelativePath;
	
	// initial pos of system. Allow to restore the initial instances of the system  when doing start / stop
	CPSInitialPos				_InitialPos;
	bool					_Modified;
	CParticleWorkspace			*_WS;
	NLMISC::CRefPtr<NL3D::CSkeletonModel> 	_ParentSkel;
	bool					_ResetAutoCount;
	//
	std::string				_ParentSkelName;
	std::string				_ParentBoneName;
private:
	void setup(NL3D::CParticleSystemModel &psm);
public:
	bool getResetAutoCountFlag() const { return _ResetAutoCount; }
	void setResetAutoCountFlag(bool reset) { _ResetAutoCount = reset; }
	
	/// Stick to a skeleton
	void stickPSToSkeleton(NL3D::CSkeletonModel *skel,
						   uint bone,
						   const std::string &parentSkelName, // for callback after loading
						   const std::string &parentBoneName 
						  );
	void unstickPSFromSkeleton();
private:
	friend class CParticleWorkspace;
	// Ctor
	CWorkspaceNode();
public:
	// DTor
	~CWorkspaceNode();
}; /* class CWorkspaceNode */

typedef std::vector<NLMISC::CRefPtr<CWorkspaceNode> > TNodeVect;
typedef TNodeVect::iterator		TPWNodeItr;

/** 
@class CParticleWorkspace
@author Nicolas Vizerie
@author Nevrax France
@date 2004
@brief A container containing all the loaded particle system.
@details Allows you to load \ save in xml file list of systems of particles (the path to each file as well)
and additional parameters (skeleton model, and to which bone it is attached)
There is a feedback mechanism showed changes are being made with the container,with a particle system or connection to the skeleton. 
*/
class CParticleWorkspace
{
public:		
	/// callback to know when a workspace node has been modified
	struct IModificationCallback
	{
		virtual void workspaceModifiedFlagChanged(CParticleWorkspace &pw) = 0;
		virtual void nodeModifiedFlagChanged(CWorkspaceNode &node) = 0;
		virtual void nodeSkelParentChanged(CWorkspaceNode &node) = 0; // called when fx has been linked / unlinked from a skeleton parent
	};
	/// Сonstructor
	CParticleWorkspace();
	/// Destructor
	~CParticleWorkspace();

	/// Init the workspace for the given object viewer
	/// must be called prior to other methods	
	void init(const std::string &filename);
	
	/// Set a new name for the workspace (not its filename)
	void setName(const std::string &name);
	
	/// Set a new file name for the workspace
	void setFileName(const std::string &fileName);
	
	std::string getName() const { return _Name; }
	
	/// Get the path in which workpsace is located with a trailing slash
	std::string getPath() const;
	std::string getFilename() const;

	/// Get Number of nodes in the workspace
	uint getNumNode() const { return (uint)_Nodes.size(); }
	
	/// Get a node in workspace
	/// Can keep pointer safely as long as the node is not deleted
	CWorkspaceNode *getNode(uint index) const { return _Nodes[index]; }
	
	/// Get a node from a pointer on a particle system
	CWorkspaceNode *getNodeFromPS(NL3D::CParticleSystem *ps) const;
	
	/// Test if the workspace already contains a node with the given filename name
	/// NB : 2 node with the same name re not allowed, even if their path is different
	bool containsFile(std::string filename) const;

	/// Add a node in the workspace. Will succeed only if fx filename does not already exist in the workspace.
	/// The node is in the 'unloaded' state, so caller must load it afterward.          
	/// NB : no lookup is done, full path must be provided. 
	/// @return pointer to new node, or NULL if already inserted	  
	CWorkspaceNode *addNode(const std::string &filenameWithFullPath) throw( NLMISC::Exception);
	
	/// Remove a node by it's index
	void removeNode(uint index);
	
	/// Remove a node by it's pointer
	void removeNode(CWorkspaceNode *ptr);
	
	/// Get index of a node from its pointer, or -1 if not found
	sint getIndexFromNode(CWorkspaceNode *node) const;
	
	/// Save the workspace structure. The target file is the one given when this object was created	  
	/// NB : ps shape are not saved, only the structure is. To save the shapes, call CNode::save()
	void save() throw(NLMISC::EStream);
	
	/// Load the workspace structure. The target file is the one given when this object was created
	/// All nodes are in the 'unloaded" state, so it is to the caller to load them by calling load() on their node
	void load() throw(NLMISC::EStream);
	
	/// Test whether the structure of the workspace has been modified (does not test if ps inside the workspace have been modified)
	bool isModified() const { return _Modified; }
	
	/// Test whether the content of the workspace has ben modified
	bool isContentModified() const;
	void touch() { setModifiedFlag(true); }
	void clearModifiedFlag() { setModifiedFlag(false); }
	
	/// Set a callback to know when a node is modified
	void setModificationCallback(IModificationCallback *cb) { _ModificationCallback = cb; }		
	IModificationCallback  *getModificationCallback() const { return _ModificationCallback; }	
	
	/// Restick all objects, useful after loading
	void restickAllObjects();

	TNodeVect& getNodeList() { return _Nodes; }

private:
	// use smart ptr to avoir prb wih resize
	TNodeVect		_Nodes;
	// path + name of workspace
	std::string		_Filename;  
	bool			_Modified;
	IModificationCallback	*_ModificationCallback;
	// workspace user name
	std::string		_Name;
	
	/// serial the object
	void serial(NLMISC::IStream &f) throw(NLMISC::EStream);	
	
	/// set the 'modified flag' and call the callback
	void setModifiedFlag(bool modified);

public:
	void nodeModified(CWorkspaceNode &node);
}; /* class CParticleWorkspace */


} /* namespace NLQT */

#endif // PARTICLE_NODE_H