Merge pull request #298 from Madrich/master

Collada fixes, adding XFile Exporter

code/CMakeLists.txt

@@ -187,7 +187,7 @@ SET( Collada_SRCS
 	ColladaParser.cpp
 	ColladaParser.h
 	ColladaExporter.h
-	ColladaExporter.cpp
+	ColladaExporter.cpp	
 )
 SOURCE_GROUP( Collada FILES ${Collada_SRCS})
 
@@ -543,6 +543,8 @@ SET( XFile_SRCS
 	XFileImporter.h
 	XFileParser.cpp
 	XFileParser.h
+	XFileExporter.h
+	XFileExporter.cpp
 )
 SOURCE_GROUP( XFile FILES ${XFile_SRCS})
 

code/ColladaExporter.cpp

@@ -58,7 +58,7 @@ namespace Assimp
 
 // ------------------------------------------------------------------------------------------------
 // Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
-void ExportSceneCollada(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene)
+void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
 {
 	std::string path = "";
 	std::string file = pFile;
@@ -124,7 +124,7 @@ ColladaExporter::~ColladaExporter()
 void ColladaExporter::WriteFile()
 {
 	// write the DTD
-	mOutput << "<?xml version=\"1.0\"?>" << endstr;
+	mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
 	// COLLADA element start
 	mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
 	PushTag();
@@ -151,7 +151,7 @@ void ColladaExporter::WriteFile()
 // Writes the asset header
 void ColladaExporter::WriteHeader()
 {
-	static const float epsilon = 0.000001f;
+	static const float epsilon = 0.00001f;
 	static const aiQuaternion x_rot(aiMatrix3x3( 
 		0, -1,  0,
 		1,  0,  0,
@@ -176,6 +176,7 @@ void ColladaExporter::WriteHeader()
 	aiQuaternion rotation;
 	aiVector3D position;
 	mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
+	rotation.Normalize();
 
 	bool add_root_node = false;
 
@@ -229,8 +230,22 @@ void ColladaExporter::WriteHeader()
 	PushTag();
 	mOutput << startstr << "<contributor>" << endstr;
 	PushTag();
-	mOutput << startstr << "<author>Assimp</author>" << endstr;
-	mOutput << startstr << "<authoring_tool>Assimp Collada Exporter</authoring_tool>" << endstr;
+
+	aiMetadata* meta = mScene->mRootNode->mMetaData;
+	aiString value;
+	if (!meta || !meta->Get("Author", value))		
+		mOutput << startstr << "<author>" << "Assimp" << "</author>" << endstr;
+	else		
+		mOutput << startstr << "<author>" << value.C_Str() << "</author>" << endstr;
+
+	if (!meta || !meta->Get("AuthoringTool", value))
+		mOutput << startstr << "<authoring_tool>" << "Assimp Exporter" << "</authoring_tool>" << endstr;
+	else		
+		mOutput << startstr << "<authoring_tool>" << value.C_Str() << "</authoring_tool>" << endstr;
+
+	//mOutput << startstr << "<author>" << mScene->author.C_Str() << "</author>" << endstr;
+	//mOutput << startstr << "<authoring_tool>" << mScene->authoringTool.C_Str() << "</authoring_tool>" << endstr;
+	
 	PopTag();
 	mOutput << startstr << "</contributor>" << endstr;
 	mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
@@ -353,7 +368,8 @@ void ColladaExporter::WriteTextureColorEntry( const Surface& pSurface, const std
     if( pSurface.texture.empty() )
     {
       mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
-    } else
+    }
+	else
     {
       mOutput << startstr << "<texture texture=\"" << pImageName << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
     }
@@ -420,12 +436,12 @@ void ColladaExporter::WriteMaterials()
 
     aiString name;
     if( mat->Get( AI_MATKEY_NAME, name) != aiReturn_SUCCESS )
-      name = "mat";
+      name = "mat";
     materials[a].name = std::string( "m") + boost::lexical_cast<std::string> (a) + name.C_Str();
     for( std::string::iterator it = materials[a].name.begin(); it != materials[a].name.end(); ++it ) {
 		// isalnum on MSVC asserts for code points in [0,255]. Thus prevent unwanted promotion
 		// of char to signed int and take the unsigned char value.
-      if( !isalnum( static_cast<uint8_t>(*it) ) ) {
+      if( !isalnum( static_cast<uint8_t>(*it) ) ) {
         *it = '_';
 	  }
 	}
@@ -630,26 +646,63 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
 	PopTag();
 	mOutput << startstr << "</vertices>" << endstr;
 
-	// write face setup
-	mOutput << startstr << "<polylist count=\"" << mesh->mNumFaces << "\" material=\"theresonlyone\">" << endstr;
-	PushTag();
-	mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstr << "-vertices\" />" << endstr;
-	
-	mOutput << startstr << "<vcount>";
-	for( size_t a = 0; a < mesh->mNumFaces; ++a )
-		mOutput << mesh->mFaces[a].mNumIndices << " ";
-	mOutput << "</vcount>" << endstr;
-	
-	mOutput << startstr << "<p>";
+	// count the number of lines, triangles and polygon meshes
+	int countLines = 0;
+	int countPoly = 0;
 	for( size_t a = 0; a < mesh->mNumFaces; ++a )
 	{
-		const aiFace& face = mesh->mFaces[a];
-		for( size_t b = 0; b < face.mNumIndices; ++b )
-			mOutput << face.mIndices[b] << " ";
+		if (mesh->mFaces[a].mNumIndices == 2) countLines++;
+		else if (mesh->mFaces[a].mNumIndices >= 3) countPoly++;
+	}
+
+	// lines
+	if (countLines)
+	{
+		mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
+		PushTag();
+		mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstr << "-vertices\" />" << endstr;
+		mOutput << startstr << "<p>";
+		for( size_t a = 0; a < mesh->mNumFaces; ++a )
+		{
+			const aiFace& face = mesh->mFaces[a];
+			if (face.mNumIndices != 2) continue;
+			for( size_t b = 0; b < face.mNumIndices; ++b )
+				mOutput << face.mIndices[b] << " ";
+		}
+		mOutput << "</p>" << endstr;
+		PopTag();
+		mOutput << startstr << "</lines>" << endstr;
+	}
+
+	// triangle - dont use it, because compatibility problems
+
+	// polygons
+	if (countPoly)
+	{		
+		mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
+		PushTag();
+		mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstr << "-vertices\" />" << endstr;
+	
+		mOutput << startstr << "<vcount>";
+		for( size_t a = 0; a < mesh->mNumFaces; ++a )
+		{
+			if (mesh->mFaces[a].mNumIndices < 3) continue;
+			mOutput << mesh->mFaces[a].mNumIndices << " ";
+		}
+		mOutput << "</vcount>" << endstr;
+	
+		mOutput << startstr << "<p>";
+		for( size_t a = 0; a < mesh->mNumFaces; ++a )
+		{
+			const aiFace& face = mesh->mFaces[a];
+			if (face.mNumIndices < 3) continue;
+			for( size_t b = 0; b < face.mNumIndices; ++b )
+				mOutput << face.mIndices[b] << " ";
+		}
+		mOutput << "</p>" << endstr;
+		PopTag();
+		mOutput << startstr << "</polylist>" << endstr;
 	}
-	mOutput << "</p>" << endstr;
-	PopTag();
-	mOutput << startstr << "</polylist>" << endstr;
 
 	// closing tags
 	PopTag();
@@ -770,8 +823,16 @@ void ColladaExporter::WriteSceneLibrary()
 
 // ------------------------------------------------------------------------------------------------
 // Recursively writes the given node
-void ColladaExporter::WriteNode( const aiNode* pNode)
+void ColladaExporter::WriteNode(aiNode* pNode)
 {
+	// the must have a name
+	if (pNode->mName.length == 0)
+	{		
+		std::stringstream ss;
+		ss << "Node_" << pNode;
+		pNode->mName.Set(ss.str());
+	}
+
 	mOutput << startstr << "<node id=\"" << pNode->mName.data << "\" name=\"" << pNode->mName.data << "\">" << endstr;
 	PushTag();
 
@@ -799,7 +860,7 @@ void ColladaExporter::WriteNode( const aiNode* pNode)
 	PushTag();
 	mOutput << startstr << "<technique_common>" << endstr;
 	PushTag();
-	mOutput << startstr << "<instance_material symbol=\"theresonlyone\" target=\"#" << materials[mesh->mMaterialIndex].name << "\" />" << endstr;
+	mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << materials[mesh->mMaterialIndex].name << "\" />" << endstr;
 		PopTag();
 	mOutput << startstr << "</technique_common>" << endstr;
 	PopTag();

code/ColladaExporter.h

@@ -92,7 +92,7 @@ protected:
 	void WriteSceneLibrary();
 
 	/// Recursively writes the given node
-	void WriteNode( const aiNode* pNode);
+	void WriteNode( aiNode* pNode);
 
 	/// Enters a new xml element, which increases the indentation
 	void PushTag() { startstr.append( "  "); }

code/ConvertToLHProcess.cpp

@@ -134,7 +134,7 @@ void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh)
 	{
 		pMesh->mVertices[a].z *= -1.0f;
 		if( pMesh->HasNormals())
-			pMesh->mNormals[a].z *= -1.0f;
+			pMesh->mNormals[a].z *= -1.0f;		
 		if( pMesh->HasTangentsAndBitangents())
 		{
 			pMesh->mTangents[a].z *= -1.0f;

code/Exporter.cpp

@@ -71,7 +71,9 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
 
 // ------------------------------------------------------------------------------------------------
 // Exporter worker function prototypes. Should not be necessary to #ifndef them, it's just a prototype
+// do not use const, because some exporter need to convert the scene temporary
 void ExportSceneCollada(const char*,IOSystem*, const aiScene*);
+void ExportSceneXFile(const char*,IOSystem*, const aiScene*); 
 void ExportSceneObj(const char*,IOSystem*, const aiScene*);
 void ExportSceneSTL(const char*,IOSystem*, const aiScene*);
 void ExportSceneSTLBinary(const char*,IOSystem*, const aiScene*);
@@ -86,6 +88,11 @@ Exporter::ExportFormatEntry gExporters[] =
 	Exporter::ExportFormatEntry( "collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada),
 #endif
 
+#ifndef ASSIMP_BUILD_NO_FXILE_EXPORTER
+	Exporter::ExportFormatEntry( "x", "X Files", "x", &ExportSceneXFile,
+	aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs),
+#endif
+
 #ifndef ASSIMP_BUILD_NO_OBJ_EXPORTER
 	Exporter::ExportFormatEntry( "obj", "Wavefront OBJ format", "obj", &ExportSceneObj, 
 		aiProcess_GenSmoothNormals /*| aiProcess_PreTransformVertices */),

code/ObjExporter.h

@@ -38,7 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-/** @file ColladaExporter.h
+/** @file ObjExporter.h
  * Declares the exporter class to write a scene to a Collada file
  */
 #ifndef AI_OBJEXPORTER_H_INC

code/XFileExporter.cpp

@@ -0,0 +1,517 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+@author: Richard Steffen, 2014
+----------------------------------------------------------------------
+*/
+
+#include "AssimpPCH.h"
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_XFILE_EXPORTER
+#include "XFileExporter.h"
+#include "ConvertToLHProcess.h"
+#include "Bitmap.h"
+#include "fast_atof.h"
+#include "SceneCombiner.h" 
+
+#include <ctime>
+#include <set>
+
+using namespace Assimp;
+
+namespace Assimp
+{
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
+void ExportSceneXFile(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene)
+{
+	std::string path = "";
+	std::string file = pFile;
+
+	// We need to test both types of folder separators because pIOSystem->getOsSeparator() is not reliable.
+	// Moreover, the path given by some applications is not even consistent with the OS specific type of separator.
+	const char* end_path = std::max(strrchr(pFile, '\\'), strrchr(pFile, '/'));
+
+	if(end_path != NULL) {
+		path = std::string(pFile, end_path + 1 - pFile);
+		file = file.substr(end_path + 1 - pFile, file.npos);
+
+		std::size_t pos = file.find_last_of('.');
+		if(pos != file.npos) {
+			file = file.substr(0, pos);
+		}
+	}
+
+	// invoke the exporter 
+	XFileExporter iDoTheExportThing( pScene, pIOSystem, path, file);
+
+	// we're still here - export successfully completed. Write result to the given IOSYstem
+	boost::scoped_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+	if(outfile == NULL) {
+		throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
+	}
+
+	// XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
+	outfile->Write( iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()),1);
+}
+
+} // end of namespace Assimp
+
+
+// ------------------------------------------------------------------------------------------------
+// Constructor for a specific scene to export
+XFileExporter::XFileExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file) : mIOSystem(pIOSystem), mPath(path), mFile(file)
+{
+	// make sure that all formatting happens using the standard, C locale and not the user's current locale
+	mOutput.imbue( std::locale("C") );
+
+	mScene = pScene;
+	mSceneOwned = false;
+
+	// set up strings
+	endstr = "\n"; 
+
+	// start writing
+	WriteFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor
+XFileExporter::~XFileExporter()
+{
+	if(mSceneOwned) {
+		delete mScene;
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Starts writing the contents
+void XFileExporter::WriteFile()
+{
+	// note, that all realnumber values must be comma separated in x files
+	mOutput.setf(std::ios::fixed);
+	mOutput.precision(6); // precission for float
+
+	// entry of writing the file
+	WriteHeader();
+
+	mOutput << startstr << "Frame DXCC_ROOT {" << endstr;
+	PushTag();
+
+	aiMatrix4x4 I; // identity
+	WriteFrameTransform(I);
+
+	WriteNode(mScene->mRootNode);
+	PopTag();
+
+	mOutput << startstr << "}" << endstr;
+
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the asset header
+void XFileExporter::WriteHeader()
+{
+	mOutput << startstr << "xof 0303txt 0032" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template Frame {" << endstr;
+	PushTag();
+	mOutput << startstr << "<3d82ab46-62da-11cf-ab39-0020af71e433>" << endstr;
+	mOutput << startstr << "[...]" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template Matrix4x4 {" << endstr;
+	PushTag();
+	mOutput << startstr << "<f6f23f45-7686-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "array FLOAT matrix[16];" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template FrameTransformMatrix {" << endstr;
+	PushTag();
+	mOutput << startstr << "<f6f23f41-7686-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "Matrix4x4 frameMatrix;" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template Vector {" << endstr;
+	PushTag();
+	mOutput << startstr << "<3d82ab5e-62da-11cf-ab39-0020af71e433>" << endstr;
+	mOutput << startstr << "FLOAT x;" << endstr;
+	mOutput << startstr << "FLOAT y;" << endstr;
+	mOutput << startstr << "FLOAT z;" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template MeshFace {" << endstr;
+	PushTag();
+	mOutput << startstr << "<3d82ab5f-62da-11cf-ab39-0020af71e433>" << endstr;
+	mOutput << startstr << "DWORD nFaceVertexIndices;" << endstr;
+	mOutput << startstr << "array DWORD faceVertexIndices[nFaceVertexIndices];" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template Mesh {" << endstr;
+	PushTag();
+	mOutput << startstr << "<3d82ab44-62da-11cf-ab39-0020af71e433>" << endstr;
+	mOutput << startstr << "DWORD nVertices;" << endstr;
+	mOutput << startstr << "array Vector vertices[nVertices];" << endstr;
+	mOutput << startstr << "DWORD nFaces;" << endstr;
+	mOutput << startstr << "array MeshFace faces[nFaces];" << endstr;
+	mOutput << startstr << "[...]" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template MeshNormals {" << endstr;
+	PushTag();
+	mOutput << startstr << "<f6f23f43-7686-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "DWORD nNormals;" << endstr;
+	mOutput << startstr << "array Vector normals[nNormals];" << endstr;
+	mOutput << startstr << "DWORD nFaceNormals;" << endstr;
+	mOutput << startstr << "array MeshFace faceNormals[nFaceNormals];" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template Coords2d {" << endstr;
+	PushTag();
+	mOutput << startstr << "<f6f23f44-7686-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "FLOAT u;" << endstr;
+	mOutput << startstr << "FLOAT v;" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template MeshTextureCoords {" << endstr;
+	PushTag();
+	mOutput << startstr << "<f6f23f40-7686-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "DWORD nTextureCoords;" << endstr;
+	mOutput << startstr << "array Coords2d textureCoords[nTextureCoords];" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template ColorRGBA {" << endstr;
+	PushTag();
+	mOutput << startstr << "<35ff44e0-6c7c-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "FLOAT red;" << endstr;
+	mOutput << startstr << "FLOAT green;" << endstr;
+	mOutput << startstr << "FLOAT blue;" << endstr;
+	mOutput << startstr << "FLOAT alpha;" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template IndexedColor {" << endstr;
+	PushTag();
+	mOutput << startstr << "<1630b820-7842-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "DWORD index;" << endstr;
+	mOutput << startstr << "ColorRGBA indexColor;" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template MeshVertexColors {" << endstr;
+	PushTag();
+	mOutput << startstr << "<1630b821-7842-11cf-8f52-0040333594a3>" << endstr;
+	mOutput << startstr << "DWORD nVertexColors;" << endstr;
+	mOutput << startstr << "array IndexedColor vertexColors[nVertexColors];" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template VertexElement {" << endstr;
+	PushTag();
+	mOutput << startstr << "<f752461c-1e23-48f6-b9f8-8350850f336f>" << endstr;
+	mOutput << startstr << "DWORD Type;" << endstr;
+	mOutput << startstr << "DWORD Method;" << endstr;
+	mOutput << startstr << "DWORD Usage;" << endstr;
+	mOutput << startstr << "DWORD UsageIndex;" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+	mOutput << startstr << "template DeclData {" << endstr;
+	PushTag();
+	mOutput << startstr << "<bf22e553-292c-4781-9fea-62bd554bdd93>" << endstr;
+	mOutput << startstr << "DWORD nElements;" << endstr;
+	mOutput << startstr << "array VertexElement Elements[nElements];" << endstr;
+	mOutput << startstr << "DWORD nDWords;" << endstr;
+	mOutput << startstr << "array DWORD data[nDWords];" << endstr;
+	PopTag();
+	mOutput << startstr << "}" << endstr;
+	mOutput << endstr;
+}
+
+
+// Writes the material setup
+void XFileExporter::WriteFrameTransform(aiMatrix4x4& m)
+{
+	mOutput << startstr << "FrameTransformMatrix {" << endstr << " ";
+	PushTag();
+	mOutput << startstr << m.a1 << ", " << m.b1 << ", " << m.c1 << ", " << m.d1 << "," << endstr;
+    mOutput << startstr << m.a2 << ", " << m.b2 << ", " << m.c2 << ", " << m.d2 << "," << endstr;
+	mOutput << startstr << m.a3 << ", " << m.b3 << ", " << m.c3 << ", " << m.d3 << "," << endstr;
+	mOutput << startstr << m.a4 << ", " << m.b4 << ", " << m.c4 << ", " << m.d4 << ";;" << endstr;		
+	PopTag();
+	mOutput << startstr << "}" << endstr << endstr;
+}
+
+
+// ------------------------------------------------------------------------------------------------
+// Recursively writes the given node
+void XFileExporter::WriteNode( aiNode* pNode)
+{	
+	if (pNode->mName.length==0)
+	{
+		std::stringstream ss;
+		ss << "Node_" << pNode;
+		pNode->mName.Set(ss.str());
+	}
+	mOutput << startstr << "Frame " << pNode->mName.C_Str() << " {" << endstr;
+
+	PushTag();
+
+	aiMatrix4x4 m = pNode->mTransformation;
+
+	WriteFrameTransform(m);
+
+	for (size_t i = 0; i < pNode->mNumMeshes; i++)
+		WriteMesh(mScene->mMeshes[pNode->mMeshes[i]]);
+
+	// recursive call the Nodes
+	for (size_t a = 0; a < pNode->mNumChildren; a++)
+		WriteNode( mScene->mRootNode->mChildren[a]);
+
+	PopTag();
+
+	mOutput << startstr << "}" << endstr << endstr;
+}
+
+void XFileExporter::WriteMesh(const aiMesh* mesh)
+{
+	mOutput << startstr << "Mesh " << mesh->mName.C_Str() << "_mShape" << " {" << endstr;
+
+	PushTag();
+
+	// write all the vertices
+	mOutput << startstr << mesh->mNumVertices << ";" << endstr;	
+	for (size_t a = 0; a < mesh->mNumVertices; a++)
+	{
+		aiVector3D &v = mesh->mVertices[a];
+		mOutput << startstr << v[0] << ";"<< v[1] << ";" << v[2] << ";";
+		if (a < mesh->mNumVertices - 1)
+			mOutput << "," << endstr;
+		else
+			mOutput << ";" << endstr;
+	}
+
+	// write all the faces
+	mOutput << startstr << mesh->mNumFaces << ";" << endstr;
+	for( size_t a = 0; a < mesh->mNumFaces; ++a )
+	{
+		const aiFace& face = mesh->mFaces[a];
+		mOutput << startstr << face.mNumIndices << ";";
+		// must be counter clockwise triangle
+		//for(int b = face.mNumIndices - 1; b >= 0 ; --b)
+		for(size_t b = 0; b < face.mNumIndices ; ++b)
+		{
+			mOutput << face.mIndices[b];
+			//if (b > 0)
+			if (b<face.mNumIndices-1)
+				mOutput << ",";
+			else
+				mOutput << ";";
+		}
+
+		if (a < mesh->mNumFaces - 1)
+			mOutput << "," << endstr;
+		else
+			mOutput << ";" << endstr;
+	}
+
+	mOutput << endstr;
+
+	if (mesh->HasTextureCoords(0))
+	{
+		const aiMaterial* mat = mScene->mMaterials[mesh->mMaterialIndex];
+		aiString relpath;
+		mat->Get(_AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0, relpath);		
+
+		mOutput << startstr << "MeshMaterialList {" << endstr;
+		PushTag();
+		mOutput << startstr << "1;" << endstr; // number of materials
+		mOutput << startstr << mesh->mNumFaces << ";" << endstr; // number of faces
+		mOutput << startstr;
+		for( size_t a = 0; a < mesh->mNumFaces; ++a )
+		{		
+			mOutput << "0"; // the material index
+			if (a < mesh->mNumFaces - 1)
+				mOutput << ", ";
+			else
+				mOutput << ";" << endstr;
+		}		
+		mOutput << startstr << "Material {" << endstr;	
+		PushTag();
+		mOutput << startstr << "1.0; 1.0; 1.0; 1.000000;;" << endstr;
+		mOutput << startstr << "1.000000;" << endstr; // power
+		mOutput << startstr << "0.000000; 0.000000; 0.000000;;" << endstr; // specularity
+		mOutput << startstr << "0.000000; 0.000000; 0.000000;;" << endstr; // emission
+		mOutput << startstr << "TextureFilename { \"";
+
+		writePath(relpath);		
+
+		mOutput << "\"; }" << endstr;	
+		PopTag();
+		mOutput << startstr << "}" << endstr;
+		PopTag();
+		mOutput << startstr << "}" << endstr;	
+	}
+
+	// write normals (every vertex has one)
+	if (mesh->HasNormals())
+	{
+		mOutput << endstr << startstr << "MeshNormals {" << endstr;
+		mOutput << startstr << mesh->mNumVertices << ";" << endstr;
+		for (size_t a = 0; a < mesh->mNumVertices; a++)
+		{		
+			aiVector3D &v = mesh->mNormals[a];
+			// because we have a LHS and also changed wth winding, we need to invert the normals again
+			mOutput << startstr << -v[0] << ";"<< -v[1] << ";" << -v[2] << ";";
+			if (a < mesh->mNumVertices - 1)
+				mOutput << "," << endstr;
+			else
+				mOutput << ";" << endstr;
+		}
+
+		mOutput << startstr << mesh->mNumFaces << ";" << endstr;
+		for (size_t a = 0; a < mesh->mNumFaces; a++)
+		{		
+			const aiFace& face = mesh->mFaces[a];
+			mOutput << startstr << face.mNumIndices << ";";
+
+			//for(int b = face.mNumIndices-1; b >= 0 ; --b)
+			for(size_t b = 0; b < face.mNumIndices ; ++b)
+			{
+				mOutput << face.mIndices[b];
+				//if (b > 0)
+				if (b<face.mNumIndices-1)
+					mOutput << ",";
+				else
+					mOutput << ";";
+			}
+
+			if (a < mesh->mNumFaces-1)
+				mOutput << "," << endstr;
+			else
+				mOutput << ";" << endstr;
+		}
+		mOutput << startstr << "}" << endstr;
+	}
+	
+	// write texture UVs if available
+	if (mesh->HasTextureCoords(0))
+	{		
+		mOutput << endstr << startstr << "MeshTextureCoords {"  << endstr;
+		mOutput << startstr << mesh->mNumVertices << ";" << endstr;
+		for (size_t a = 0; a < mesh->mNumVertices; a++)
+		//for (int a = (int)mesh->mNumVertices-1; a >=0 ; a--)
+		{
+			aiVector3D& uv = mesh->mTextureCoords[0][a]; // uv of first uv layer for the vertex
+			mOutput << startstr << uv.x << ";" << uv.y;
+			if (a < mesh->mNumVertices-1)
+			//if (a >0 )
+				mOutput << ";," << endstr;
+			else
+				mOutput << ";;" << endstr;
+		}
+		mOutput << startstr << "}" << endstr;
+	}
+
+	// write color channel if available
+	if (mesh->HasVertexColors(0))
+	{		
+		mOutput << endstr << startstr << "MeshVertexColors {"  << endstr;
+		mOutput << startstr << mesh->mNumVertices << ";" << endstr;
+		for (size_t a = 0; a < mesh->mNumVertices; a++)
+		{
+			aiColor4D& mColors = mesh->mColors[0][a]; // color of first vertex color set for the vertex
+			mOutput << startstr << a << ";" << mColors.r << ";" << mColors.g << ";" << mColors.b << ";" << mColors.a << ";;";
+			if (a < mesh->mNumVertices-1)
+				mOutput << "," << endstr;
+			else
+				mOutput << ";" << endstr;
+		}
+		mOutput << startstr << "}" << endstr;
+	}
+	/*
+	else
+	{
+		mOutput << endstr << startstr << "MeshVertexColors {"  << endstr;
+		mOutput << startstr << mesh->mNumVertices << ";" << endstr;
+		for (size_t a = 0; a < mesh->mNumVertices; a++)
+		{
+			aiColor4D* mColors = mesh->mColors[a];
+			mOutput << startstr << a << ";0.500000;0.000000;0.000000;0.500000;;";
+			if (a < mesh->mNumVertices-1)
+				mOutput << "," << endstr;
+			else
+				mOutput << ";" << endstr;
+		}
+		mOutput << startstr << "}" << endstr;
+	}
+	*/
+	PopTag();
+	mOutput << startstr << "}" << endstr << endstr;
+
+}
+
+
+void XFileExporter::writePath(aiString path)
+{
+	std::string str = std::string(path.C_Str());
+	BaseImporter::ConvertUTF8toISO8859_1(str);
+
+	while( str.find( "\\\\") != std::string::npos)
+		str.replace( str.find( "\\\\"), 2, "\\");
+
+	while( str.find( "\\") != std::string::npos)
+		str.replace( str.find( "\\"), 1, "/");
+
+	mOutput << str;
+			
+}
+
+#endif
+#endif
+

code/XFileExporter.h

@@ -0,0 +1,125 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2012, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+@author: Richard Steffen, 2014
+
+----------------------------------------------------------------------
+*/
+
+/** @file XFileExporter.h
+ * Declares the exporter class to write a scene to a Collada file
+ */
+#ifndef AI_XFILEEXPORTER_H_INC
+#define AI_XFILEEXPORTER_H_INC
+
+#include "../include/assimp/ai_assert.h"
+#include <sstream>
+
+struct aiScene;
+struct aiNode;
+
+namespace Assimp	
+{
+
+/// Helper class to export a given scene to a X-file.
+/// Note: an xFile uses a left hand system. Assimp used a right hand system (OpenGL), therefore we have to transform everything
+class XFileExporter
+{
+public:
+	/// Constructor for a specific scene to export
+	XFileExporter(const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file);
+
+	/// Destructor
+	virtual ~XFileExporter();
+
+protected:
+	/// Starts writing the contents
+	void WriteFile();	
+
+	/// Writes the asset header
+	void WriteHeader();
+
+	/// write a frame transform
+	void WriteFrameTransform(aiMatrix4x4& m);
+
+	/// Recursively writes the given node
+	void WriteNode( aiNode* pNode );
+
+	/// write a mesh entry of the scene
+	void WriteMesh(const aiMesh* mesh);
+
+	/// Enters a new xml element, which increases the indentation
+	void PushTag() { startstr.append( "  "); }
+
+	/// Leaves an element, decreasing the indentation
+	void PopTag() { ai_assert( startstr.length() > 1); startstr.erase( startstr.length() - 2); }
+
+public:
+	/// Stringstream to write all output into
+	std::stringstream mOutput;
+
+protected:
+
+	/// write a path
+	void writePath(aiString path);	
+
+	/// The IOSystem for output
+	IOSystem* mIOSystem;
+
+	/// Path of the directory where the scene will be exported
+	const std::string mPath;
+
+	/// Name of the file (without extension) where the scene will be exported
+	const std::string mFile;
+
+	/// The scene to be written
+	const aiScene* mScene;
+	bool mSceneOwned;
+
+	/// current line start string, contains the current indentation for simple stream insertion
+	std::string startstr;
+
+	/// current line end string for simple stream insertion
+	std::string endstr;
+  
+protected:
+
+};
+
+}
+
+#endif // !! AI_XFILEEXPORTER_H_INC

include/assimp/Exporter.hpp

@@ -81,7 +81,7 @@ class ASSIMP_API Exporter
 public:
 
 	/** Function pointer type of a Export worker function */
-	typedef void (*fpExportFunc)(const char*,IOSystem*,const aiScene*);
+	typedef void (*fpExportFunc)(const char*,IOSystem*, const aiScene*);
 
 	/** Internal description of an Assimp export format option */
 	struct ExportFormatEntry