- Colladawriter does now reset correctly (calling writeMesh twice failed...

- Colladawriter does now reset correctly (calling writeMesh twice failed before and writeScene twice didn't write light-nodes second time)
- Add some callbacks that allow users to use custom-names on writing
(I'll probably add an example as well soon for how to use all that - the problem is that there don't seem to be 2 tools out there interpreting Collada the same way and so we have to be rather flexible on export. And yeah - our own import also still  has way to go...)

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@4268 dfc29bdd-3216-0410-991c-e03cc46cb475

include/IColladaMeshWriter.h

@@ -77,7 +77,6 @@ namespace scene
 	};
 
 	//! Callback interface for properties which can be used to influence collada writing
-	//! NOTE: Interface is still work in process and might change some more before 1.8 release
 	class IColladaMeshWriterProperties  : public virtual IReferenceCounted
 	{
 	public:
@@ -131,13 +130,106 @@ namespace scene
 		virtual IMesh* getMesh(irr::scene::ISceneNode * node) = 0;
 	};
 
+	//! Callback interface to use custom names on collada writing.
+	/** Many names and id's have to be unique in collada. By default 
+	Irrlicht guarantees for example by using using pointer-values in the name.
+	This works for most tools, but occasionally you might need another naming scheme
+	to make it easier finding names again for further processing.
+	*/
+	class IColladaMeshWriterNames  : public virtual IReferenceCounted
+	{
+	public:
+	
+		IColladaMeshWriterNames() : MeshToNC(true), NodeToNC(true), NCNamePrefix(L"_NC_") {}
+		virtual ~IColladaMeshWriterNames () {}
+
+		//! Return a unique name for the given mesh
+		/** Note that names really must be unique here per mesh-pointer, so mostly it's a good idea to return
+		the nameForMesh from IColladaMeshWriter::getDefaultNameGenerator().
+		*/
+		virtual irr::core::stringw nameForMesh(const scene::IMesh* mesh) const = 0;
+
+		//! Return a unique name for the given node
+		/** Note that names really must be unique here per node-pointer, so mostly it's a good idea to return
+		the nameForNode from IColladaMeshWriter::getDefaultNameGenerator().
+		*/
+		virtual irr::core::stringw nameForNode(const scene::ISceneNode* node) const = 0;
+
+		//! Return a name for the material
+		/** There is one material created in the writer for each unique name. So you can use this to control 
+		the number of materials which get written. For example Irrlicht does by default write one material for each
+		material instanced by a node. So if you know that in your application material instances per node are identical 
+		between different nodes you can reduce the number of exported materials using that knowledge by using identical 
+		names for such shared materials. */
+		virtual irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node) const = 0;
+
+		//! Ensure meshnames follow the xs::NCName format (so this will change names!)
+		/** Names need to have a certain format in collada, like not starting with numbers,
+		and avoiding certain special characters. 
+		*/
+		void SetConvertMeshNameToNC(bool doConvert)	
+		{ 
+			MeshToNC = doConvert; 
+		}
+
+		//! Check if meshnames are forced to follow the xs::NCName format
+		bool GetConvertMeshNameToNC() const 
+		{
+			return MeshToNC;
+		}
+
+		//! Ensure nodenames follow the xs::NCName format (so this will change names!)
+		void SetConvertNodeNameToNC(bool doConvert)	
+		{ 
+			NodeToNC = doConvert; 
+		}
+
+		//! Check if nodenames are forced to follow the xs::NCName format
+		bool GetConvertNodeNameToNC() const 
+		{
+			return NodeToNC;
+		}
+
+		//! Ensure materialnames follow the xs::NCName format (so this will change names!)
+		void SetConvertMaterialNameToNC(bool doConvert)	
+		{ 
+			MaterialToNC = doConvert; 
+		}
+
+		//! Check if materialnames are forced to follow the xs::NCName format
+		bool GetConvertMaterialNameToNC() const 
+		{
+			return MaterialToNC;
+		}
+
+		//! When conversion to NCName's is enforced resulting names will have this prefix
+		void SetNCNamePrefix(const irr::core::stringw& prefix) 
+		{
+			NCNamePrefix = prefix;
+		}
+
+		//! Get the NCName prefix
+		const irr::core::stringw& getNCNamePrefix() const
+		{
+			return NCNamePrefix;
+		}
+
+	protected:
+		bool MeshToNC;
+		bool NodeToNC;
+		bool MaterialToNC;
+		irr::core::stringw NCNamePrefix;
+	};
+
 
 	//! Interface for writing meshes
 	class IColladaMeshWriter : public IMeshWriter
 	{
 	public:
 
-		IColladaMeshWriter() : Properties(0), DefaultProperties(0), WriteTextures(true), WriteDefaultScene(false), AmbientLight(0.f, 0.f, 0.f, 1.f)
+		IColladaMeshWriter() 
+			: Properties(0), DefaultProperties(0), NameGenerator(0), DefaultNameGenerator(0)
+			, WriteTextures(true), WriteDefaultScene(false), AmbientLight(0.f, 0.f, 0.f, 1.f)
 		{
 		}
 
@@ -148,6 +240,10 @@ namespace scene
 				Properties->drop();
 			if ( DefaultProperties )
 				DefaultProperties->drop();
+			if ( NameGenerator )
+				NameGenerator->drop();
+			if ( DefaultNameGenerator )
+				DefaultNameGenerator->drop();
 		}
 
 		//! writes a scene starting with the given node
@@ -209,7 +305,7 @@ namespace scene
 		}
 
 		//! Get properties which are currently used.
-		virtual IColladaMeshWriterProperties * getProperties()
+		virtual IColladaMeshWriterProperties * getProperties() const
 		{
 			return Properties;
 		}
@@ -221,8 +317,34 @@ namespace scene
 			return DefaultProperties; 
 		}
 
+		//! Install a generator to create custom names on export. 
+		virtual void setNameGenerator(IColladaMeshWriterNames * nameGenerator)
+		{
+			if ( nameGenerator == NameGenerator )
+				return;
+			if ( nameGenerator ) 
+				nameGenerator->grab();
+			if ( NameGenerator )
+				NameGenerator->drop();
+			NameGenerator = nameGenerator;
+		}
+
+		//! Get currently used name generator
+		virtual IColladaMeshWriterNames * getNameGenerator() const
+		{
+			return NameGenerator;
+		}
+
+		//! Return the original default name generator of the writer. 
+		/** You can use this pointer in your own generator to access and return default values. */
+		IColladaMeshWriterNames * getDefaultNameGenerator() const 
+		{ 
+			return DefaultNameGenerator; 
+		}
+
+
 	protected:
-		// NOTE: you should also call setProperties
+		// NOTE: You usually should also call setProperties with the same paraemter when using setDefaultProperties
 		virtual void setDefaultProperties(IColladaMeshWriterProperties * p)
 		{
 			if ( p == DefaultProperties )
@@ -234,9 +356,23 @@ namespace scene
 			DefaultProperties = p;
 		}
 
+		// NOTE: You usually should also call setNameGenerator with the same paraemter when using setDefaultProperties
+		virtual void setDefaultNameGenerator(IColladaMeshWriterNames * p)
+		{
+			if ( p == DefaultNameGenerator )
+				return;
+			if ( p ) 
+				p->grab();
+			if ( DefaultNameGenerator )
+				DefaultNameGenerator->drop();
+			DefaultNameGenerator = p;
+		}
+
 	private:
 		IColladaMeshWriterProperties * Properties;
 		IColladaMeshWriterProperties * DefaultProperties;
+		IColladaMeshWriterNames * NameGenerator;
+		IColladaMeshWriterNames * DefaultNameGenerator;
 		bool WriteTextures;
 		bool WriteDefaultScene;
 		video::SColorf AmbientLight;

source/Irrlicht/CColladaMeshWriter.h

@@ -56,6 +56,18 @@ namespace scene
 		virtual irr::scene::IMesh* getMesh(irr::scene::ISceneNode * node);
 	};
 
+	class CColladaMeshWriterNames  : public virtual IColladaMeshWriterNames
+	{
+	public:
+		CColladaMeshWriterNames();
+		virtual irr::core::stringw nameForMesh(const scene::IMesh* mesh) const;
+		virtual irr::core::stringw nameForNode(const scene::ISceneNode* node) const;
+		virtual irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node) const;
+	protected:
+		irr::core::stringw nameForPtr(const void* ptr) const;
+	};
+
+
 
 //! class to write meshes, implementing a COLLADA (.dae, .xml) writer
 /** This writer implementation has been originally developed for irrEdit and then
@@ -79,6 +91,7 @@ public:
 
 protected:
 
+	void reset();
 	bool hasSecondTextureCoordinates(video::E_VERTEX_TYPE type) const;
 	void writeUv(const irr::core::vector2df& vec);
 	void writeVector(const irr::core::vector2df& vec);
@@ -89,8 +102,9 @@ protected:
 	inline irr::core::stringw toString(const irr::scene::E_COLLADA_TRANSPARENT_FX opaque) const;
 	inline irr::core::stringw toRef(const irr::core::stringw& source) const;
 	irr::core::stringw nameForMesh(const scene::IMesh* mesh) const;
-	irr::core::stringw nameForLightNode(const scene::ISceneNode* lightNode) const;
 	irr::core::stringw nameForNode(const scene::ISceneNode* node) const;
+	irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node) const;
+	irr::core::stringw nameForMaterialSymbol(const scene::IMesh* mesh, int materialId) const;
 	irr::core::stringw nameForPtr(const void* ptr) const;
 	irr::core::stringw minTexfilterToString(bool bilinear, bool trilinear) const;
 	irr::core::stringw magTexfilterToString(bool bilinear, bool trilinear) const;
@@ -107,8 +121,8 @@ protected:
 	void writeNodeLights(irr::scene::ISceneNode * node);
 	void writeNodeGeometries(irr::scene::ISceneNode * node);
 	void writeSceneNode(irr::scene::ISceneNode * node);
-	void writeMeshMaterials(const irr::core::stringw& meshname, scene::IMesh* mesh);
-	void writeMeshEffects(const irr::core::stringw& meshname, scene::IMesh* mesh);
+	void writeMeshMaterials(scene::IMesh* mesh);
+	void writeMeshEffects(scene::IMesh* mesh);
 	void writeMaterialEffect(const irr::core::stringw& meshname, const irr::core::stringw& materialname, const video::SMaterial & material);
 	void writeMeshGeometry(const irr::core::stringw& meshname, scene::IMesh* mesh);
 	void writeMeshInstanceGeometry(const irr::core::stringw& meshname, scene::IMesh* mesh, scene::ISceneNode* node=0);
@@ -154,15 +168,16 @@ protected:
 	core::array<video::ITexture*> LibraryImages;
 	io::path Directory;
 
+	// Check per mesh-ptr if stuff has been written for this mesh already
 	struct ColladaMesh
 	{
-		ColladaMesh() : MaterialWritten(false), EffectWritten(false), GeometryWritten(false)
+		ColladaMesh() : MaterialsWritten(false), EffectsWritten(false), GeometryWritten(false)
 		{
 		}
 
 		irr::core::stringw Name;
-		bool MaterialWritten;
-		bool EffectWritten;
+		bool MaterialsWritten;	// just an optimization doing that here in addition to the MaterialsWritten map
+		bool EffectsWritten;	// just an optimization doing that here in addition to the EffectsWritten map
 		bool GeometryWritten;
 	};
 	typedef core::map<IMesh*, ColladaMesh>::Node MeshNode;
@@ -175,6 +190,11 @@ protected:
 	};
 	typedef core::map<ISceneNode*, ColladaLight>::Node LightNode;
 	core::map<ISceneNode*, ColladaLight> LightNodes;
+
+	// Check per name if stuff has been written already 
+	// TODO: second parameter not needed, we just don't have a core::set class yet in Irrlicht
+	core::map<irr::core::stringw, bool> MaterialsWritten;
+	core::map<irr::core::stringw, bool> EffectsWritten;
 };
 
 
@@ -182,5 +202,3 @@ protected:
 } // end namespace
 
 #endif
-
-