/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 3 of the License, or
 (at your option) any later version.

 GLC-lib 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *****************************************************************************/

#include "glc_colladatoworld.h"
#include "../sceneGraph/glc_world.h"
#include "../glc_fileformatexception.h"
#include "../maths/glc_geomtools.h"
#include "../glc_factory.h"
#include "glc_xmlutil.h"

static QString prefixNodeId= "GLC_LIB_COLLADA_ID_";
static int currentNodeId= 0;

using namespace glcXmlUtil;

// Default constructor
GLC_ColladaToWorld::GLC_ColladaToWorld()
: QObject()
, m_pWorld(NULL)
, m_pStreamReader(NULL)
, m_FileName()
, m_pFile()
, m_ImageFileHash()
, m_MaterialLibHash()
, m_SurfaceImageHash()
, m_MaterialEffectHash()
, m_pCurrentMaterial(NULL)
, m_TextureToMaterialHash()
, m_BulkDataHash()
, m_DataAccessorHash()
, m_VerticesSourceHash()
, m_pMeshInfo(NULL)
, m_GeometryHash()
, m_ColladaNodeHash()
, m_TopLevelColladaNode()
, m_MaterialInstanceMap()
, m_3DRepHash()
, m_StructInstanceHash()
, m_CurrentId()
, m_FileSize(0)
, m_CurrentOffset(0)
, m_ListOfAttachedFileName()
, m_TransparentIsRgbZero(false)
{
	currentNodeId= 0;
}

// Destructor
GLC_ColladaToWorld::~GLC_ColladaToWorld()
{
	// Normal ends, wold has not to be deleted
	m_pWorld= NULL;
	clear();
}

//////////////////////////////////////////////////////////////////////
// Set Functions
//////////////////////////////////////////////////////////////////////
// Create an GLC_World from an input Collada File
GLC_World* GLC_ColladaToWorld::CreateWorldFromCollada(QFile &file)
{
	m_pWorld= new GLC_World();
	m_FileName= file.fileName();
	m_pFile= &file;

	//////////////////////////////////////////////////////////////////
	// Test if the file exist and can be opened
	//////////////////////////////////////////////////////////////////
	if (!m_pFile->open(QIODevice::ReadOnly))
	{
		QString message(QString("GLC_ColladaToWorld::CreateWorldFromCollada File ") + m_FileName + QString(" doesn't exist"));
		GLC_FileFormatException fileFormatException(message, m_FileName, GLC_FileFormatException::FileNotFound);
		throw(fileFormatException);
	}
	// Get the file size
	m_FileSize= QFileInfo(m_FileName).size();

	m_pStreamReader= new QXmlStreamReader(m_pFile);

	// Go to the collada root Element
	goToElement("COLLADA");

	// Read the collada version
	QString version= readAttribute("version", true);

	// Go to the asset Element to get the Up vector
	goToElement("asset");
	while (endElementNotReached(m_pStreamReader, "asset"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "up_axis")
			{
				const QString upAxis= getContent("up_axis");
				if (upAxis == "X_UP") m_pWorld->setUpVector(glc::X_AXIS);
				else if (upAxis == "Y_UP") m_pWorld->setUpVector(glc::Y_AXIS);
				else if (upAxis == "Z_UP") m_pWorld->setUpVector(glc::Z_AXIS);
			}
		}
		m_pStreamReader->readNext();
	}

	while (endElementNotReached(m_pStreamReader, "COLLADA"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "library_images") loadLibraryImage();
			else if (currentElementName == "library_materials") loadLibraryMaterials();
			else if (currentElementName == "library_effects") loadLibraryEffects();
			else if (currentElementName == "library_geometries") loadLibraryGeometries();
			else if (currentElementName == "library_nodes") loadLibraryNodes();
			else if (currentElementName == "library_controllers") loadLibraryContollers();
			else if (currentElementName == "library_visual_scenes") loadVisualScenes();
			else if (currentElementName == "scene") loadScene();
		}

		m_pStreamReader->readNext();
	}
	// Link the textures to materials
	linkTexturesToMaterials();

	// Create the mesh and link them to material
	createMesh();

	// Create the scene graph struct
	createSceneGraph();

	emit currentQuantum(100);

	return m_pWorld;
}

//////////////////////////////////////////////////////////////////////
// Private services Functions
//////////////////////////////////////////////////////////////////////
// Go to Element
void GLC_ColladaToWorld::goToElement(const QString& elementName)
{
	while(startElementNotReached(m_pStreamReader, elementName))
	{
		m_pStreamReader->readNext();
	}
	checkForXmlError(QString("Element ") + elementName + QString(" Not Found"));
}

// Go to the end Element of a xml
void GLC_ColladaToWorld::goToEndElement(const QString& elementName)
{
	while(endElementNotReached(m_pStreamReader, elementName))
	{
		m_pStreamReader->readNext();
	}
	checkForXmlError(QString("End Element ") + elementName + QString(" Not Found"));
}

// Return the content of an element
QString GLC_ColladaToWorld::getContent(const QString& element)
{
	QString Content;
	while(endElementNotReached(m_pStreamReader, element))
	{
		m_pStreamReader->readNext();
		if (m_pStreamReader->isCharacters() && !m_pStreamReader->text().isEmpty())
		{
			Content+= m_pStreamReader->text().toString();
		}
	}

	return Content.simplified();
}

// Read the specified attribute
QString GLC_ColladaToWorld::readAttribute(const QString& name, bool required)
{
	QString attributeValue;
	if (required && !m_pStreamReader->attributes().hasAttribute(name))
	{
		QString message(QString("required attribute ") + name + QString(" Not found"));
		GLC_FileFormatException fileFormatException(message, m_FileName, GLC_FileFormatException::WrongFileFormat);
		clear();
		throw(fileFormatException);
	}
	else
	{
		attributeValue= m_pStreamReader->attributes().value(name).toString();
	}
	return attributeValue;
}

// Check for XML error
void GLC_ColladaToWorld::checkForXmlError(const QString& info)
{
	if (m_pStreamReader->atEnd() || m_pStreamReader->hasError())
	{
		GLC_FileFormatException fileFormatException(info, m_FileName, GLC_FileFormatException::WrongFileFormat);
		clear();
		throw(fileFormatException);
	}
}
// Throw an exception with the specified text
void GLC_ColladaToWorld::throwException(const QString& message)
{
	GLC_FileFormatException fileFormatException(message, m_FileName, GLC_FileFormatException::WrongFileFormat);
	clear();
	throw(fileFormatException);
}

// Clear memmory
void GLC_ColladaToWorld::clear()
{
	delete m_pWorld;
	m_pWorld= NULL;

	delete m_pStreamReader;
	m_pStreamReader= NULL;

	if (NULL != m_pFile) m_pFile->close();
	m_pFile= NULL;

	m_ImageFileHash.clear();
	m_MaterialLibHash.clear();
	m_SurfaceImageHash.clear();

	// Clear the material effect hash table
	MaterialHash::iterator iMat= m_MaterialEffectHash.begin();
	while (iMat != m_MaterialEffectHash.constEnd())
	{
		if (iMat.value()->isUnused()) delete iMat.value();
		++iMat;
	}
	m_MaterialEffectHash.clear();

	delete m_pCurrentMaterial;
	m_pCurrentMaterial= NULL;

	m_TextureToMaterialHash.clear();

	m_BulkDataHash.clear();
	m_DataAccessorHash.clear();

	m_VerticesSourceHash.clear();

	delete m_pMeshInfo;
	m_pMeshInfo= NULL;

	// Delete all geometry from the geometry hash
	QHash<const QString, MeshInfo*>::iterator iGeomHash= m_GeometryHash.begin();
	while (m_GeometryHash.constEnd() != iGeomHash)
	{
		delete iGeomHash.value();
		++iGeomHash;
	}
	m_GeometryHash.clear();

	// Delete all collada node from the colalda node hash
	QHash<const QString, ColladaNode*>::iterator iColladaNode= m_ColladaNodeHash.begin();
	while (m_ColladaNodeHash.constEnd() != iColladaNode)
	{
		delete iColladaNode.value();
		++iColladaNode;
	}
	m_ColladaNodeHash.clear();

	// Clear the list of top level node (Not must not to be deleted)
	m_TopLevelColladaNode.clear();

	// Clear the material instance map
	m_MaterialInstanceMap.clear();

	//! Delete all 3DRep
	QHash<const QString, GLC_3DRep*>::iterator i3DRep= m_3DRepHash.begin();
	while (m_3DRepHash.constEnd() != i3DRep)
	{
		delete i3DRep.value();
		++i3DRep;
	}
	m_3DRepHash.clear();

	// Clear instance Hash table
	m_StructInstanceHash.clear();

	m_CurrentId.clear();

	m_ListOfAttachedFileName.clear();
}

// Load library_images element
void GLC_ColladaToWorld::loadLibraryImage()
{
	while (endElementNotReached(m_pStreamReader, "library_images"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "image") loadImage();
		}
		m_pStreamReader->readNext();

		updateProgressBar();
	}
	checkForXmlError("Error occur while loading element : library_images");
}

// Load image element
void GLC_ColladaToWorld::loadImage()
{
	//qDebug() << "GLC_ColladaToWorld::loadImage()";
	// load image id
	m_CurrentId= readAttribute("id", true);
	QString fileName;
	// Trying to find external image fileName
	while (endElementNotReached(m_pStreamReader, "image"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "init_from")
			{
				fileName= getContent("init_from");
			}
		}
		m_pStreamReader->readNext();
	}

	checkForXmlError("Error occur while loading element : image");

	// Add the image in the image fileName Hash table
	if (!fileName.isEmpty())
	{
		m_ImageFileHash.insert(m_CurrentId, fileName);
	}
}

// Load library_materials element
void GLC_ColladaToWorld::loadLibraryMaterials()
{
	while (endElementNotReached(m_pStreamReader, "library_materials"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "material") loadMaterial();
		}
		m_pStreamReader->readNext();

		updateProgressBar();
	}
	checkForXmlError("Error occur while loading element : library_materials");

}

// Load a material
void GLC_ColladaToWorld::loadMaterial()
{
	// load material id
	m_CurrentId= readAttribute("id", true);

	goToElement("instance_effect");

	// Load instance effect url
	const QString url= readAttribute("url", true).remove('#');
	//qDebug() << "instance effect URL : " << url;

	// Read instance effect parameters
	while (endElementNotReached(m_pStreamReader, "instance_effect"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "setparam")
			{
				qDebug() << "GLC_ColladaToWorld::loadMaterial : setparam found";
			}
		}
		m_pStreamReader->readNext();
	}

	checkForXmlError("Error occur while loading element : material");

	// Add the image in the image fileName Hash table
	if (!url.isEmpty())
	{
		//qDebug() << "insert material : " << m_CurrentId << " url: " << url;
		m_MaterialLibHash.insert(m_CurrentId, url);
	}

}

// Load library_effects element
void GLC_ColladaToWorld::loadLibraryEffects()
{
	while (endElementNotReached(m_pStreamReader, "library_effects"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "effect") loadEffect();
		}
		m_pStreamReader->readNext();

		updateProgressBar();
	}
	checkForXmlError("Error occur while loading element : library_effects");

}

// Load an effect
void GLC_ColladaToWorld::loadEffect()
{
	// load effect id
	const QString id= readAttribute("id", true);
	m_CurrentId= id;
	m_pCurrentMaterial= new GLC_Material();
	m_pCurrentMaterial->setName(id);

	while (endElementNotReached(m_pStreamReader, "effect"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "profile_COMMON") loadProfileCommon();
		}
		m_pStreamReader->readNext();
	}

	checkForXmlError("Error occur while loading element : effect");

	m_MaterialEffectHash.insert(id, m_pCurrentMaterial);
	m_pCurrentMaterial= NULL;

}

// Load profile_COMMON
void GLC_ColladaToWorld::loadProfileCommon()
{
	//qDebug() << "GLC_ColladaToWorld::loadProfileCommon";
	while (endElementNotReached(m_pStreamReader, "profile_COMMON"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "image") loadImage();
			else if (currentElementName == "newparam") loadNewParam();
			else if (currentElementName == "technique") loadTechnique();
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : profile_COMMON");
}

// Load a new param of the common profile
void GLC_ColladaToWorld::loadNewParam()
{
	//qDebug() << "GLC_ColladaToWorld::loadNewParam";
	// load param sid
	const QString sid= m_CurrentId + "::" + readAttribute("sid", true);
	while (endElementNotReached(m_pStreamReader, "newparam"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "surface") loadSurface(sid);
			else if (currentElementName == "sampler2D") loadSampler2D(sid);
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : profile_COMMON");
}

// Load a surface
void GLC_ColladaToWorld::loadSurface(const QString& sid)
{
	//qDebug() << "GLC_ColladaToWorld::loadSurface sid=" << sid ;
	while (endElementNotReached(m_pStreamReader, "surface"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "init_from")
			{
				const QString imageId= getContent("init_from");
				m_SurfaceImageHash.insert(sid, imageId);
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : surface");
}

// Load Sampler 2D
void GLC_ColladaToWorld::loadSampler2D(const QString& sid)
{
	//qDebug() << "GLC_ColladaToWorld::loadSampler2D sid= " << sid;
	while (endElementNotReached(m_pStreamReader, "sampler2D"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "source")
			{
				const QString source= m_CurrentId + "::" + getContent("source");
				m_Sampler2DSurfaceHash.insert(sid, source);
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : sampler2D");
}

// Load technique
void GLC_ColladaToWorld::loadTechnique()
{
	//qDebug() << "GLC_ColladaToWorld::loadTechnique";
	while (endElementNotReached(m_pStreamReader, "technique"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "phong") loadMaterialTechnique(currentElementName.toString());
			if (currentElementName == "lambert") loadMaterialTechnique(currentElementName.toString());
			if (currentElementName == "blinn") loadMaterialTechnique(currentElementName.toString());
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : technique");
}

// load phong material
void GLC_ColladaToWorld::loadMaterialTechnique(const QString& elementName)
{
	//qDebug() << "GLC_ColladaToWorld::loadMaterialTechnique";
	while (endElementNotReached(m_pStreamReader, elementName))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "emission")
					|| (currentElementName == "ambient")
					|| (currentElementName == "diffuse")
					||(currentElementName == "specular"))
				loadCommonColorOrTexture(currentElementName.toString());
			else if (currentElementName == "transparent") loadTransparent();
			else if (currentElementName == "transparency") loadTransparency(currentElementName.toString());
			else if (currentElementName == "shininess") loadShininess(currentElementName.toString());
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : " + elementName);
}

// load common color or texture
void GLC_ColladaToWorld::loadCommonColorOrTexture(const QString& name)
{
	//qDebug() << "GLC_ColladaToWorld::loadCommonColorOrTexture " << name;
	Q_ASSERT(NULL != m_pCurrentMaterial);

	while (endElementNotReached(m_pStreamReader, name))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "color")
			{
				if (name == "emission") m_pCurrentMaterial->setEmissiveColor(readXmlColor());
				else if (name == "ambient") m_pCurrentMaterial->setAmbientColor(readXmlColor());
				else if (name == "diffuse") m_pCurrentMaterial->setDiffuseColor(readXmlColor());
				else if (name == "specular") m_pCurrentMaterial->setSpecularColor(readXmlColor());
			}
			else if (currentElementName == "texture")
			{
				//qDebug() << "Load texture " << name;
				const QString sid = m_CurrentId + "::" + readAttribute("texture", true);
				m_TextureToMaterialHash.insert(sid, m_pCurrentMaterial);
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : " + name);
}

// Load transparent
void GLC_ColladaToWorld::loadTransparent()
{
	const QString opaque= readAttribute("opaque", false);
	if (opaque == "RGB_ZERO") m_TransparentIsRgbZero= true;
	else m_TransparentIsRgbZero= false;
}

// Load transparency
void GLC_ColladaToWorld::loadTransparency(const QString& name)
{
	//qDebug() << "GLC_ColladaToWorld::loadTransparency";
	Q_ASSERT(NULL != m_pCurrentMaterial);
	while (endElementNotReached(m_pStreamReader, name))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "float")
			{
				bool stringToFloatOk= false;
				const QString alphaString= getContent("float");
				float alpha;
				if (m_TransparentIsRgbZero)
				{
					alpha= alphaString.toFloat(&stringToFloatOk);
				}
				else
				{
					alpha= 1.0f - alphaString.toFloat(&stringToFloatOk);
				}
				// A material mustn't be invisible (no sense)
				if (qFuzzyCompare(alpha, 0.0f)) alpha= 1.0f;

				m_pCurrentMaterial->setOpacity(alpha);
				if (!stringToFloatOk) throwException("Error while trying to convert :" + alphaString + " to float");
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : " + name);
}

// Load shininess
void GLC_ColladaToWorld::loadShininess(const QString& name)
{
	//qDebug() << "GLC_ColladaToWorld::loadShininess";
	Q_ASSERT(NULL != m_pCurrentMaterial);
	while (endElementNotReached(m_pStreamReader, name))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "float")
			{
				bool stringToFloatOk= false;
				const QString shininessString= getContent("float");
				const float shininess= shininessString.toFloat(&stringToFloatOk);
				if (!stringToFloatOk)
				{
					QStringList stringList(m_FileName);
					stringList.append("Error while trying to convert :" + shininessString + " to float");
					GLC_ErrorLog::addError(stringList);
				}
				else m_pCurrentMaterial->setShininess(shininess);
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : " + name);
}

// Read a xml Color
QColor GLC_ColladaToWorld::readXmlColor()
{
	//qDebug() << "GLC_ColladaToWorld::readXmlColor()";
	QColor resultColor;

	QString colorString= getContent("color");
	QStringList colors= colorString.split(' ');
	if(colors.size() == 4)
	{
		bool okRed, okGreen, okBlue, okAlpha;
		const float red= colors.at(0).toFloat(&okRed);
		const float green= colors.at(1).toFloat(&okGreen);
		const float blue= colors.at(2).toFloat(&okBlue);
		const float alpha= colors.at(3).toFloat(&okAlpha);
		if (okRed && okGreen && okBlue && okAlpha)
		{
			resultColor.setRedF(red);
			resultColor.setGreenF(green);
			resultColor.setBlueF(blue);
			resultColor.setAlphaF(alpha);
		}
		else
		{
			QString info= "Error occur while reading xml color : " + colorString;
			qDebug() << info << " " << m_FileName;
			GLC_FileFormatException fileFormatException(info, m_FileName, GLC_FileFormatException::WrongFileFormat);
			clear();
			throw(fileFormatException);
		}
	}
	else
	{
		QString info= "Error occur while reading xml color : " + colorString;
		qDebug() << info << " " << m_FileName;
		GLC_FileFormatException fileFormatException(info, m_FileName, GLC_FileFormatException::WrongFileFormat);
		clear();
		throw(fileFormatException);
	}

	return resultColor;
}

// Load library_geometries element
void GLC_ColladaToWorld::loadLibraryGeometries()
{
	while (endElementNotReached(m_pStreamReader, "library_geometries"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "geometry") loadGeometry();
		}

		m_pStreamReader->readNext();

		updateProgressBar();
	}
	checkForXmlError("Error occur while loading element : library_geometries");
}

// Load an geometry element
void GLC_ColladaToWorld::loadGeometry()
{
	delete m_pMeshInfo;
	m_pMeshInfo= new MeshInfo();
	m_pMeshInfo->m_pMesh= new GLC_Mesh;

	const QString id= readAttribute("id", false);
	m_CurrentId= id;
	if (!id.isEmpty())
	{
		m_pMeshInfo->m_pMesh->setName(id);
		//qDebug() << "Loading geometry : " << id;
	}
	else
	{
		qDebug() << "Geometry without id found !!";
	}

	while (endElementNotReached(m_pStreamReader, "geometry"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "mesh") loadMesh();
		}

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : geometry");

	// Add the current mesh info to the geometry hash
	if (!id.isEmpty())
	{
		m_GeometryHash.insert(id, m_pMeshInfo);
		m_pMeshInfo= NULL;
	}
}

// Load a mesh
void GLC_ColladaToWorld::loadMesh()
{
	while (endElementNotReached(m_pStreamReader, "mesh"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "source") loadVertexBulkData();
			else if (currentElementName == "vertices") loadVertices();
			else if (currentElementName == "polylist") loadPolylist();
			else if (currentElementName == "polygons") loadPolygons();
			else if (currentElementName == "triangles") loadTriangles();
			//else if (currentElementName == "trifans") loadTriFans();
			//else if (currentElementName == "tristrips") loadTriStrip();
		}

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : mesh");
}

// Load Vertex bulk data
void GLC_ColladaToWorld::loadVertexBulkData()
{
	//qDebug() << "GLC_ColladaToWorld::loadVertexBulkData()";
	// load Vertex Bulk data id
	m_CurrentId= readAttribute("id", true);
	//qDebug() << "id=" << m_CurrentId;
	QList<float> vertices;

	while (endElementNotReached(m_pStreamReader, "source"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "float_array"))
			{
				int count= readAttribute("count", true).toInt();
				QString array= getContent("float_array");
				QStringList list= array.split(' ');
				// Check the array size
				if (count != list.size()) throwException("float_array size not match");

				for (int i= 0; i < count; ++i)
				{
					vertices.append(list.at(i).toFloat());
				}
			}
			else if (currentElementName == "technique_common") loadTechniqueCommon();
		}

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : source");
	m_BulkDataHash.insert(m_CurrentId, vertices);

	updateProgressBar();
}

void GLC_ColladaToWorld::loadTechniqueCommon()
{
	//qDebug() << "GLC_ColladaToWorld::loadTechniqueCommon()";

	while (endElementNotReached(m_pStreamReader, "technique_common"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "accessor")) loadAccessor();
		}

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : technique_common");

}

void GLC_ColladaToWorld::loadAccessor()
{
	//qDebug() << "GLC_ColladaToWorld::loadAccessor()";
	Accessor accessor;
	const QString count= readAttribute("count", true);
	const QString offset= readAttribute("offset", false);
	const QString stride= readAttribute("stride", false);
	bool conversionOk;
	accessor.m_Count= count.toUInt(&conversionOk);
	if (conversionOk)
	{
		if (!offset.isEmpty())
		{
			accessor.m_Offset= offset.toUInt(&conversionOk);
		}
		if (!stride.isEmpty())
		{
			accessor.m_Stride= stride.toUInt(&conversionOk);
		}
	}

	while (endElementNotReached(m_pStreamReader, "accessor"))
	{
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : technique_common");

	m_DataAccessorHash.insert(m_CurrentId, accessor);
}

// Load attributes and identity of mesh vertices
void GLC_ColladaToWorld::loadVertices()
{
	//qDebug() << "GLC_ColladaToWorld::loadVertices()";
	// load Vertices id
	m_CurrentId= readAttribute("id", true);

	goToElement("input");
	const QString source= readAttribute("source", true).remove('#');
	m_VerticesSourceHash.insert(m_CurrentId, source);
	checkForXmlError("Error occur while loading element : vertices");
}

// Load polygons or polylist
void GLC_ColladaToWorld::loadPolylist()
{
	//qDebug() << "GLC_ColladaToWorld::loadPolylist()";
	// The number of polygon
	const int polygonCount= readAttribute("count", true).toInt();

	// The material id
	const QString materialId= readAttribute("material", false);

	// Offsets and data source list
	QList<InputData> inputDataList;

	// Polygon number of vertice list
	QList<int> vcountList;

	// Polygon index list
	QList<int> polyIndexList;

	while (endElementNotReached(m_pStreamReader, "polylist"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "input") && vcountList.isEmpty())
			{
				InputData currentInput;
				// Get input data offset
				currentInput.m_Offset= readAttribute("offset", true).toInt();
				// Get input data semantic
				const QString semantic= readAttribute("semantic", true);
				if (semantic == "VERTEX") currentInput.m_Semantic= VERTEX;
				else if (semantic == "NORMAL") currentInput.m_Semantic= NORMAL;
				else if (semantic == "TEXCOORD") currentInput.m_Semantic= TEXCOORD;
				else throwException("Source semantic :" + semantic + "Not supported");
				// Get input data source id
				currentInput.m_Source= readAttribute("source", true).remove('#');

				// Bypasss vertices indirection
				if (m_VerticesSourceHash.contains(currentInput.m_Source))
				{
					currentInput.m_Source= m_VerticesSourceHash.value(currentInput.m_Source);
				}
				inputDataList.append(currentInput);
			}
			else if ((currentElementName == "vcount") && (inputDataList.size() > 0))
			{
				QString vcountString= getContent("vcount");
				QStringList vcountStringList= vcountString.split(' ');
				if (vcountStringList.size() != polygonCount) throwException("vcount size not match");
				bool toIntOK;
				for (int i= 0; i < polygonCount; ++i)
				{
					vcountList.append(vcountStringList.at(i).toInt(&toIntOK));
					if (!toIntOK) throwException("Unable to convert string :" + vcountStringList.at(i) + " To int");
				}
			}
			else if ((currentElementName == "p") && !vcountList.isEmpty() && polyIndexList.isEmpty())
			{
				{ // Fill index List
					QString pString= getContent("p");
					QStringList pStringList= pString.split(' ');
					bool toIntOK;
					const int size= pStringList.size();
					for (int i= 0; i < size; ++i)
					{
						polyIndexList.append(pStringList.at(i).toInt(&toIntOK));
						if (!toIntOK) throwException("Unable to convert string :" + pStringList.at(i) + " To int");
					}
				}

			}
		}
		m_pStreamReader->readNext();
	}
	// Add the polylist to the current mesh
	addPolylistToCurrentMesh(inputDataList, vcountList, polyIndexList, materialId);

	updateProgressBar();
}

// Load Polygons
void GLC_ColladaToWorld::loadPolygons()
{
	// The material id
	const QString materialId= readAttribute("material", false);

	// Offsets and data source list
	QList<InputData> inputDataList;

	// Polygon number of vertice list
	QList<int> vcountList;

	// The input number
	int inputCount= 0;
	// Polygon index list
	QList<int> polyIndexList;
	while (endElementNotReached(m_pStreamReader, "polygons"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "input") && vcountList.isEmpty())
			{
				++inputCount;
				InputData currentInput;
				// Get input data offset
				currentInput.m_Offset= readAttribute("offset", true).toInt();
				// Get input data semantic
				const QString semantic= readAttribute("semantic", true);
				if (semantic == "VERTEX") currentInput.m_Semantic= VERTEX;
				else if (semantic == "NORMAL") currentInput.m_Semantic= NORMAL;
				else if (semantic == "TEXCOORD") currentInput.m_Semantic= TEXCOORD;
				else throwException("Source semantic :" + semantic + "Not supported");
				// Get input data source id
				currentInput.m_Source= readAttribute("source", true).remove('#');

				// Bypasss vertices indirection
				if (m_VerticesSourceHash.contains(currentInput.m_Source))
				{
					currentInput.m_Source= m_VerticesSourceHash.value(currentInput.m_Source);
				}
				inputDataList.append(currentInput);
			}
			else if (currentElementName == "p")
			{
				{ // Fill index List
					QString pString= getContent("p");
					QStringList pStringList= pString.split(' ');
					bool toIntOK;
					const int size= pStringList.size();
					for (int i= 0; i < size; ++i)
					{
						polyIndexList.append(pStringList.at(i).toInt(&toIntOK));
						if (!toIntOK) throwException("Unable to convert string :" + pStringList.at(i) + " To int");
					}
					// Add the polygon size in vcountList
					vcountList.append(size / inputCount);
				}
			}
		}
		m_pStreamReader->readNext();
	}
	// Add the polylist to the current mesh
	addPolylistToCurrentMesh(inputDataList, vcountList, polyIndexList, materialId);

	updateProgressBar();
}

// Add the polylist to the current mesh
void GLC_ColladaToWorld::addPolylistToCurrentMesh(const QList<InputData>& inputDataList, const QList<int>& vcountList, const QList<int>& polyIndexList, const QString& materialId)
{
	//qDebug() << "GLC_ColladaToWorld::addPolylistToCurrentMesh";

	const int polygonCount= vcountList.size();
	const int inputDataCount= inputDataList.size();
	const int polyIndexCount= polyIndexList.size();

	// Flag to know if the polylist has normal
	bool hasNormals= false;
	bool hasTexture= false;
	// Check the existance of data source
	for (int dataIndex= 0; dataIndex < inputDataCount; ++dataIndex)
	{
		const QString source= inputDataList.at(dataIndex).m_Source;
		if ( !m_BulkDataHash.contains(source))
		{
			throwException(" Source : " + source + " Not found");
		}
		if (inputDataList.at(dataIndex).m_Semantic == NORMAL) hasNormals= true;
		if (inputDataList.at(dataIndex).m_Semantic == TEXCOORD) hasTexture= true;
	}

	int maxOffset= 0;
	for (int i= 0; i < inputDataCount; ++i)
	{
		if (inputDataList.at(i).m_Offset > maxOffset)
		{
			maxOffset= inputDataList.at(i).m_Offset;
		}
	}
	//qDebug() << " Max Offset :" << maxOffset;

	// the polygonIndex of the polylist
	QList<int> polygonIndex;

	// Fill the mapping, bulk data and index list of the current mesh info
	for (int i= 0; i < polyIndexCount; i+= maxOffset + 1)
	{
		// Create and set the current vertice index
		ColladaVertice currentVertice;
		for (int dataIndex= 0; dataIndex < inputDataCount; ++dataIndex)
		{
			currentVertice.m_Values[inputDataList.at(dataIndex).m_Semantic]= polyIndexList.at(i + inputDataList.at(dataIndex).m_Offset);
		}

		if (m_pMeshInfo->m_Mapping.contains(currentVertice))
		{
			// Add the the index to the polygon index
			polygonIndex.append(m_pMeshInfo->m_Mapping.value(currentVertice));
		}
		else
		{
			// Add the current vertice to the current mesh info mapping hash table and increment the freeIndex
			m_pMeshInfo->m_Mapping.insert(currentVertice, (m_pMeshInfo->m_FreeIndex)++);
			// Add the the index to the polygon index
			polygonIndex.append(m_pMeshInfo->m_Mapping.value(currentVertice));

			// Add the bulk data associated to the current vertice to the current mesh info
			for (int dataIndex= 0; dataIndex < inputDataCount; ++dataIndex)
			{
				// The current input data
				InputData currentInputData= inputDataList.at(dataIndex);
				// QHash iterator on the right QList<float>
				BulkDataHash::const_iterator iBulkHash= m_BulkDataHash.find(currentInputData.m_Source);
				int stride;
				if (m_DataAccessorHash.contains(currentInputData.m_Source))
				{
					stride= m_DataAccessorHash.value(currentInputData.m_Source).m_Stride;
				}
				else if (currentInputData.m_Semantic != TEXCOORD) stride= 3; else stride= 2;
				// Firts value
				m_pMeshInfo->m_Datas[currentInputData.m_Semantic].append(iBulkHash.value().at(polyIndexList.at(i + currentInputData.m_Offset) * stride));
				// Second value
				m_pMeshInfo->m_Datas[currentInputData.m_Semantic].append(iBulkHash.value().at(polyIndexList.at(i + currentInputData.m_Offset) * stride + 1));
				// Fird value
				if (currentInputData.m_Semantic != TEXCOORD)
				{
					m_pMeshInfo->m_Datas[currentInputData.m_Semantic].append(iBulkHash.value().at(polyIndexList.at(i + currentInputData.m_Offset) * stride + 2));
				}
			}
			// Avoid problem wich occur with mesh containing materials with and without texture
			if (!hasTexture)
			{
				m_pMeshInfo->m_Datas[TEXCOORD].append(0.0);
			}

		}
	}

	// Save mesh info index offset
	const int indexOffset= m_pMeshInfo->m_Index.size();
	// Triangulate the polygons of the polylist
	// Input polygon index must start from 0 and succesive : (0 1 2 3 4)
	QList<GLuint> onePolygonIndex;
	for (int i= 0; i < polygonCount; ++i)
	{
		const int polygonSize= vcountList.at(i);
		Q_ASSERT(polygonSize > 2);
		for (int i= 0; i < polygonSize; ++i)
		{
			onePolygonIndex.append(polygonIndex.takeFirst());
		}
		// Triangulate the current polygon if the polygon as more than 3 vertice
		if (polygonSize > 3)
		{
			glc::triangulatePolygon(&onePolygonIndex, m_pMeshInfo->m_Datas.at(VERTEX));
		}
		// Add index to the mesh info
		//Q_ASSERT(not onePolygonIndex.isEmpty());
		if (!onePolygonIndex.isEmpty())
		{
			m_pMeshInfo->m_Index.append(onePolygonIndex);
		}
		else
		{
			QStringList stringList(m_FileName);
			stringList.append("Unable to triangulate a polygon of " + m_pMeshInfo->m_pMesh->name());
			GLC_ErrorLog::addError(stringList);
		}
		onePolygonIndex.clear();
	}

	// Check if normal computation is needed
	if (!hasNormals)
	{
		qDebug() << "Compute Normals with offset " << indexOffset;
		computeNormalOfCurrentPrimitiveOfCurrentMesh(indexOffset);
	}

	// Add material the current mesh info
	MatOffsetSize matInfo;
	matInfo.m_Offset= indexOffset;
	matInfo.m_size= m_pMeshInfo->m_Index.size() - indexOffset;
	m_pMeshInfo->m_Materials.insert(materialId, matInfo);

}
// Compute Normals for the current primitive element of the current mesh
void GLC_ColladaToWorld::computeNormalOfCurrentPrimitiveOfCurrentMesh(int indexOffset)
{
	const QList<float>* pData= &(m_pMeshInfo->m_Datas.at(VERTEX));
	// Fill the list of normal
	QList<float>* pNormal= &(m_pMeshInfo->m_Datas[NORMAL]);
	const int normalOffset= pNormal->size();
	const int normalCount= pData->size() - normalOffset;
	for (int i= 0; i < normalCount; ++i)
	{
		pNormal->append(0.0f);
	}
	// Compute the normals and add them to the current mesh info
	const int size= m_pMeshInfo->m_Index.size() - indexOffset;
	double xn, yn, zn;


	for (int i= indexOffset; i < size; i+=3)
	{
		// Vertex 1
		xn= pData->at(m_pMeshInfo->m_Index.at(i) * 3);
		yn= pData->at(m_pMeshInfo->m_Index.at(i) * 3 + 1);
		zn= pData->at(m_pMeshInfo->m_Index.at(i) * 3 + 2);
		const GLC_Vector3d vect1(xn, yn, zn);

		// Vertex 2
		xn= pData->at(m_pMeshInfo->m_Index.at(i + 1) * 3);
		yn= pData->at(m_pMeshInfo->m_Index.at(i + 1) * 3  + 1);
		zn= pData->at(m_pMeshInfo->m_Index.at(i + 1) * 3 + 2);
		const GLC_Vector3d vect2(xn, yn, zn);

		// Vertex 3
		xn= pData->at(m_pMeshInfo->m_Index.at(i + 2) * 3);
		yn= pData->at(m_pMeshInfo->m_Index.at(i + 2) * 3 + 1);
		zn= pData->at(m_pMeshInfo->m_Index.at(i + 2) * 3 + 2);
		const GLC_Vector3d vect3(xn, yn, zn);

		const GLC_Vector3d edge1(vect3 - vect2);
		const GLC_Vector3d edge2(vect1 - vect2);

		GLC_Vector3d normal(edge1 ^ edge2);
		normal.normalize();

		GLC_Vector3df curNormal= normal.toVector3df();
		for (int curVertex= 0; curVertex < 3; ++curVertex)
		{
			(*pNormal)[m_pMeshInfo->m_Index.at(i + curVertex) * 3]= curNormal.x();
			(*pNormal)[m_pMeshInfo->m_Index.at(i + curVertex) * 3 + 1]= curNormal.y();
			(*pNormal)[m_pMeshInfo->m_Index.at(i + curVertex) * 3 + 2]= curNormal.z();
		}
	}
}

// Load triangles
void  GLC_ColladaToWorld::loadTriangles()
{
	//qDebug() << "GLC_ColladaToWorld::loadTriangles()";
	// The material id
	const QString materialId= readAttribute("material", false);

	// Offsets and data source list
	QList<InputData> inputDataList;

	// triangle index list
	QList<int> trianglesIndexList;

	while (endElementNotReached(m_pStreamReader, "triangles"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "input") && trianglesIndexList.isEmpty())
			{
				InputData currentInput;
				// Get input data offset
				currentInput.m_Offset= readAttribute("offset", true).toInt();
				// Get input data semantic
				const QString semantic= readAttribute("semantic", true);
				if (semantic == "VERTEX") currentInput.m_Semantic= VERTEX;
				else if (semantic == "NORMAL") currentInput.m_Semantic= NORMAL;
				else if (semantic == "TEXCOORD") currentInput.m_Semantic= TEXCOORD;
				else throwException("Source semantic :" + semantic + "Not supported");
				// Get input data source id
				currentInput.m_Source= readAttribute("source", true).remove('#');

				// Bypasss vertices indirection
				if (m_VerticesSourceHash.contains(currentInput.m_Source))
				{
					currentInput.m_Source= m_VerticesSourceHash.value(currentInput.m_Source);
				}
				inputDataList.append(currentInput);
			}
			else if ((currentElementName == "p") && trianglesIndexList.isEmpty())
			{
				{ // Fill index List
					QString pString= getContent("p");
					QStringList pStringList= pString.split(' ');
					bool toIntOK;
					const int size= pStringList.size();
					for (int i= 0; i < size; ++i)
					{
						trianglesIndexList.append(pStringList.at(i).toInt(&toIntOK));
						if (!toIntOK) throwException("Unable to convert string :" + pStringList.at(i) + " To int");
					}
				}

			}
		}
		m_pStreamReader->readNext();
	}

	// Add the polylist to the current mesh
	addTrianglesToCurrentMesh(inputDataList, trianglesIndexList, materialId);

	updateProgressBar();

}

// Add the triangles to current mesh
void GLC_ColladaToWorld::addTrianglesToCurrentMesh(const QList<InputData>& inputDataList, const QList<int>& trianglesIndexList, const QString& materialId)
{
	//qDebug() << "GLC_ColladaToWorld::addTrianglesToCurrentMesh";

	const int inputDataCount= inputDataList.size();
	const int trianglesIndexCount= trianglesIndexList.size();

	// Flag to know if the polylist has normal
	bool hasNormals= false;
	bool hasTexture= false;

	// Check the existance of data source
	for (int dataIndex= 0; dataIndex < inputDataCount; ++dataIndex)
	{
		const QString source= inputDataList.at(dataIndex).m_Source;
		if ( !m_BulkDataHash.contains(source))
		{
			throwException(" Source : " + source + " Not found");
		}
		if (inputDataList.at(dataIndex).m_Semantic == NORMAL) hasNormals= true;
		if (inputDataList.at(dataIndex).m_Semantic == TEXCOORD) hasTexture= true;
	}

	int maxOffset= 0;
	for (int i= 0; i < inputDataCount; ++i)
	{
		if (inputDataList.at(i).m_Offset > maxOffset)
		{
			maxOffset= inputDataList.at(i).m_Offset;
		}
	}
	//qDebug() << " Triangles Max Offset :" << maxOffset;

	// the polygonIndex of the polylist
	QList<GLuint> trianglesIndex;

	// Fill the mapping, bulk data and index list of the current mesh info
	for (int i= 0; i < trianglesIndexCount; i+= maxOffset + 1)
	{
		// Create and set the current vertice index
		ColladaVertice currentVertice;
		for (int dataIndex= 0; dataIndex < inputDataCount; ++dataIndex)
		{
			currentVertice.m_Values[inputDataList.at(dataIndex).m_Semantic]= trianglesIndexList.at(i + inputDataList.at(dataIndex).m_Offset);
		}

		if (m_pMeshInfo->m_Mapping.contains(currentVertice))
		{
			// Add the the index to the triangles index
			trianglesIndex.append(m_pMeshInfo->m_Mapping.value(currentVertice));
		}
		else
		{
			// Add the current vertice to the current mesh info mapping hash table and increment the freeIndex
			m_pMeshInfo->m_Mapping.insert(currentVertice, (m_pMeshInfo->m_FreeIndex)++);
			// Add the the index to the triangles index
			trianglesIndex.append(m_pMeshInfo->m_Mapping.value(currentVertice));

			// Add the bulk data associated to the current vertice to the current mesh info
			for (int dataIndex= 0; dataIndex < inputDataCount; ++dataIndex)
			{
				// The current input data
				InputData currentInputData= inputDataList.at(dataIndex);
				// QHash iterator on the right QList<float>
				BulkDataHash::const_iterator iBulkHash= m_BulkDataHash.find(currentInputData.m_Source);
				int stride;
				if (m_DataAccessorHash.contains(currentInputData.m_Source))
				{
					stride= m_DataAccessorHash.value(currentInputData.m_Source).m_Stride;
				}
				else if (currentInputData.m_Semantic != TEXCOORD) stride= 3; else stride= 2;
				// Firts value
				m_pMeshInfo->m_Datas[currentInputData.m_Semantic].append(iBulkHash.value().at(trianglesIndexList.at(i + currentInputData.m_Offset) * stride));
				// Second value
				m_pMeshInfo->m_Datas[currentInputData.m_Semantic].append(iBulkHash.value().at(trianglesIndexList.at(i + currentInputData.m_Offset) * stride + 1));
				// Fird value
				if (currentInputData.m_Semantic != TEXCOORD)
				{
					m_pMeshInfo->m_Datas[currentInputData.m_Semantic].append(iBulkHash.value().at(trianglesIndexList.at(i + currentInputData.m_Offset) * stride + 2));
				}
				// Avoid problem wich occur with mesh containing materials with and without texture
				if (!hasTexture)
				{
					m_pMeshInfo->m_Datas[TEXCOORD].append(0.0);
				}
			}
		}
	}

	// Save mesh info index offset
	const int indexOffset= m_pMeshInfo->m_Index.size();

	// Add index to the mesh info
	m_pMeshInfo->m_Index.append(trianglesIndex);

	// Check if normal computation is needed
	if (!hasNormals)
	{
		computeNormalOfCurrentPrimitiveOfCurrentMesh(indexOffset);
	}

	// Add material the current mesh info
	MatOffsetSize matInfo;
	matInfo.m_Offset= indexOffset;
	matInfo.m_size= m_pMeshInfo->m_Index.size() - indexOffset;
	m_pMeshInfo->m_Materials.insertMulti(materialId, matInfo);

}

// Load the library nodes
void GLC_ColladaToWorld::loadLibraryNodes()
{
	//qDebug() << "GLC_ColladaToWorld::loadLibraryNodes";

	while (endElementNotReached(m_pStreamReader, "library_nodes"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "node"))
			{
				GLC_ColladaToWorld::ColladaNode* pNode= loadNode(NULL);
				if (NULL != pNode)
				{

				}
			}
		}

		updateProgressBar();

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : library_nodes");
}

// Load the library controllers
void GLC_ColladaToWorld::loadLibraryContollers()
{
	//qDebug() << "GLC_ColladaToWorld::loadLibraryContollers";

	while (endElementNotReached(m_pStreamReader, "library_controllers"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "controller")) loadController();
		}

		updateProgressBar();

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : library_controllers");
}

// Load library_visual_scenes element
void GLC_ColladaToWorld::loadVisualScenes()
{
	//qDebug() << "GLC_ColladaToWorld::loadVisualScenes";
	// The element library visual scene must contains a visual scene element
	goToElement("visual_scene");

	while (endElementNotReached(m_pStreamReader, "visual_scene"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if (currentElementName == "node")
			{
				GLC_ColladaToWorld::ColladaNode* pNode= loadNode(NULL);
				if (NULL != pNode)
				{
					m_TopLevelColladaNode.append(pNode);
				}
			}
		}

		updateProgressBar();

		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : visual_scene");
}

// Load an instance geometry
void GLC_ColladaToWorld::loadInstanceGeometry(ColladaNode* pNode)
{
	//qDebug() << "GLC_ColladaToWorld::loadInstanceGeometry";

	const QString url= readAttribute("url", true).remove('#');
	pNode->m_InstanceGeometryIDs.append(url);

	while (endElementNotReached(m_pStreamReader, "instance_geometry"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "instance_material"))
			{
				const QString target= readAttribute("target", true).remove('#');
				const QString symbol= readAttribute("symbol", true);
				m_MaterialInstanceMap.insert(symbol, target);
			}

		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : instance_geometry");
}

// Load an instance of node
void GLC_ColladaToWorld::loadInstanceNode(ColladaNode* pNode)
{
	//qDebug() << "GLC_ColladaToWorld::loadInstanceNode";
	const QString url= readAttribute("url", true).remove('#');
	pNode->m_InstanceOffNodeIds.append(url);
}

// Load an instance Controller
void GLC_ColladaToWorld::loadInstanceController(ColladaNode* pNode)
{
	const QString url= readAttribute("url", true).remove('#');
	pNode->m_InstanceOffNodeIds.append(url);

	while (endElementNotReached(m_pStreamReader, "instance_controller"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "instance_material"))
			{
				const QString target= readAttribute("target", true).remove('#');
				const QString symbol= readAttribute("symbol", true);
				m_MaterialInstanceMap.insert(symbol, target);
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : instance_controller");
}

// Load a collada controller node
void GLC_ColladaToWorld::loadController()
{

	m_CurrentId= readAttribute("id", true);
	while (endElementNotReached(m_pStreamReader, "controller"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();
			if ((currentElementName == "skin"))
			{
				const QString source= readAttribute("source", true).remove('#');
				ColladaNode* pNode= new ColladaNode(m_CurrentId, NULL);
				pNode->m_InstanceGeometryIDs.append(source);
				m_ColladaNodeHash.insert(m_CurrentId, pNode);
			}
		}
		m_pStreamReader->readNext();
	}
	checkForXmlError("Error occur while loading element : controller");

}

// Load a Collada Node element
GLC_ColladaToWorld::ColladaNode* GLC_ColladaToWorld::loadNode(ColladaNode* pParent)
{
	//qDebug() << "GLC_ColladaToWorld::loadNode";


	QString id= readAttribute("id", false);
	if (id.isEmpty())
	{
		id= readAttribute("name", false);
	}
	if (id.isEmpty())
	{
		id= prefixNodeId + QString::number(++currentNodeId);
	}

	qint64 currentOffset= m_pStreamReader->characterOffset();
	//qDebug() << "Load Node " << id;
	m_CurrentId= id;
	// The node
	ColladaNode* pNode= new ColladaNode(id, pParent);
	// To avoid infinite call
	//m_pStreamReader->readNext();

	while (endElementNotReached(m_pStreamReader, "node"))
	{
		if (QXmlStreamReader::StartElement == m_pStreamReader->tokenType())
		{
			const QStringRef currentElementName= m_pStreamReader->name();

			if ((currentElementName == "translate")) translateNode(pNode);
			else if ((currentElementName == "scale")) scaleNode(pNode);
			else if ((currentElementName == "rotate")) rotateNode(pNode);
			else if ((currentElementName == "matrix")) composeMatrixNode(pNode);
			else if ((currentElementName == "instance_geometry")) loadInstanceGeometry(pNode);
			else if ((currentElementName == "instance_node")) loadInstanceNode(pNode);
			else if ((currentElementName == "instance_controller")) loadInstanceController(pNode);
			else if ((currentElementName == "node"))
			{
				if (currentOffset != m_pStreamReader->characterOffset())
				{
					QString newId= readAttribute("id", false);
					if (newId.isEmpty())
					{
						//qDebug() << "Child ReadAttribute name";
						newId= readAttribute("name", false);
					}
					//qDebug() << "New ID = " << newId;
					GLC_ColladaToWorld::ColladaNode* pChildNode= loadNode(pNode);
					if (NULL != pNode)
					{
						//qDebug() << "Add child";
						pNode->m_ChildNodes.append(pChildNode);
					}
				}
			}
			else if ((currentElementName == "instance_camera")
					|| (currentElementName == "instance_light"))
			{
				// Node type not supported
				delete pNode;
				pNode= NULL;
			}
		}
		m_pStreamReader->readNext();

	}

	if (NULL != pNode)
	{
		// Add the collada node to the collada node hash table
		m_ColladaNodeHash.insert(id, pNode);
	}
	return pNode;
}


// Translate the node
void GLC_ColladaToWorld::translateNode(ColladaNode* pNode)
{
	//qDebug() << "Translate Node";
	Q_ASSERT(NULL != pNode);
	// Load translation values
	QStringList translateStringList= getContent("translate").simplified().split(' ');
	// A translation must contains 3 string
	const int size= translateStringList.size();
	if (translateStringList.size() != 3) throwException("Translate element must contains 3 floats and it's contains :" + QString::number(translateStringList.size()));
	// Convert the string to double
	double translate[3];
	bool toFloatOk= false;
	for (int i= 0; i < size; ++i)
	{
		translate[i]= static_cast<double>(translateStringList.at(i).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + translateStringList.at(i) + "Is not a float");
	}
	// Built the translation matrix
	GLC_Matrix4x4 translationMatrix(translate[0], translate[1], translate[2]);
	// Update the node matrix
	pNode->m_Matrix= pNode->m_Matrix * translationMatrix;
}

// Scale the node
void GLC_ColladaToWorld::scaleNode(ColladaNode* pNode)
{
	//qDebug() << "Scale Node";
	Q_ASSERT(NULL != pNode);
	// Load scale values
	QStringList scaleStringList= getContent("scale").simplified().split(' ');
	// A scale must contains 3 string
	const int size= scaleStringList.size();
	if (scaleStringList.size() != 3) throwException("Scale element must contains 3 floats and it's contains :" + QString::number(scaleStringList.size()));
	// Convert the string to double
	double scale[3];
	bool toFloatOk= false;
	for (int i= 0; i < size; ++i)
	{
		scale[i]= static_cast<double>(scaleStringList.at(i).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + scaleStringList.at(i) + "Is not a float");
	}
	// Built the translation matrix
	GLC_Matrix4x4 scaleMatrix;
	scaleMatrix.setMatScaling(scale[0], scale[1], scale[2]);
	scaleMatrix.optimise();
	// Update the node matrix
	pNode->m_Matrix= pNode->m_Matrix * scaleMatrix;
}

// Rotate the node
void GLC_ColladaToWorld::rotateNode(ColladaNode* pNode)
{
	//qDebug() << "Rotate Node";
	Q_ASSERT(NULL != pNode);
	// Load rotate values
	QStringList rotateStringList= getContent("rotate").simplified().split(' ');
	// A rotate must contains 4 string (Axis Vector 3 + Angle)
	const int size= rotateStringList.size();
	if (rotateStringList.size() != 4) throwException("Rotate element must contains 4 floats and it's contains :" + QString::number(rotateStringList.size()));
	// Convert the string to double
	double rotate[4];
	bool toFloatOk= false;
	for (int i= 0; i < size; ++i)
	{
		rotate[i]= static_cast<double>(rotateStringList.at(i).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + rotateStringList.at(i) + "Is not a float");
	}
	// Rotation vector
	GLC_Vector3d rotationAxis(rotate[0], rotate[1], rotate[2]);
	// Built the rotation matrix
	GLC_Matrix4x4 rotationMatrix(rotationAxis, rotate[3]);
	// Update the node matrix
	pNode->m_Matrix= pNode->m_Matrix * rotationMatrix;
}

// Compose Node matrix
void GLC_ColladaToWorld::composeMatrixNode(ColladaNode* pNode)
{
	Q_ASSERT(NULL != pNode);

	// Load matrix values
	QStringList matrixStringList= getContent("matrix").simplified().split(' ');
	// A rotate must contains 16 string 4 x 4 Matrix
	const int size= matrixStringList.size();
	if (size != 16) throwException("Matrix element must contains 16 floats and it's contains :" + QString::number(size));
	// Convert the string to double
	double matrix[16];
	bool toFloatOk= false;
	for (int i= 0; i < 4; ++i)
	{
		matrix[i]= static_cast<double>(matrixStringList.at(i * 4).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + matrixStringList.at(i) + "Is not a float");

		matrix[i + 4]= static_cast<double>(matrixStringList.at(i * 4 + 1).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + matrixStringList.at(i * 4 + 1) + "Is not a float");

		matrix[i + 8]= static_cast<double>(matrixStringList.at(i * 4 + 2).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + matrixStringList.at(i * 4 + 2) + "Is not a float");

		matrix[i + 12]= static_cast<double>(matrixStringList.at(i * 4 + 3).toFloat(&toFloatOk));
		if (!toFloatOk) throwException("The number :" + matrixStringList.at(i * 4 + 3) + "Is not a float");

	}
	// Built the matrix
	GLC_Matrix4x4 currentMatrix(matrix);
	currentMatrix.optimise();

	// Update the node matrix
	pNode->m_Matrix= pNode->m_Matrix * currentMatrix;
}

// Load scene element
void GLC_ColladaToWorld::loadScene()
{
	//qDebug() << "GLC_ColladaToWorld::loadScene";
	while (endElementNotReached(m_pStreamReader, "scene"))
	{
		// Nothing to do
		m_pStreamReader->readNext();
	}
}

// Link texture to material
void GLC_ColladaToWorld::linkTexturesToMaterials()
{
	// Iterate throuth the the texture id to material hash
	MaterialHash::iterator iMat= m_TextureToMaterialHash.begin();
	while (iMat != m_TextureToMaterialHash.constEnd())
	{
		GLC_Material* pCurrentMaterial= iMat.value();
		const QString textureId= iMat.key();

		// Check that the texture is present
		if (m_Sampler2DSurfaceHash.contains(textureId))
		{
			const QString surfaceId= m_Sampler2DSurfaceHash.value(textureId);
			if (m_SurfaceImageHash.contains(surfaceId))
			{
				const QString imageFileId=  m_SurfaceImageHash.value(surfaceId);
			}
		}
		if (m_Sampler2DSurfaceHash.contains(textureId) && m_SurfaceImageHash.contains(m_Sampler2DSurfaceHash.value(textureId))
				&& m_ImageFileHash.contains(m_SurfaceImageHash.value(m_Sampler2DSurfaceHash.value(textureId))))
		{
			const QString imageFileName= m_ImageFileHash.value(m_SurfaceImageHash.value(m_Sampler2DSurfaceHash.value(textureId)));
			QString fullImageFileName= QFileInfo(m_FileName).absolutePath() + QDir::separator() + imageFileName;
			if (QFileInfo(fullImageFileName).exists())
			{
				m_ListOfAttachedFileName << fullImageFileName;
				GLC_Texture* pTexture= new GLC_Texture(fullImageFileName);
				pCurrentMaterial->setTexture(pTexture);
			}
			else if (QFileInfo(m_FileName).absolutePath() != QFileInfo(fullImageFileName).absolutePath())
			{
				// Trying to find image in collada file path
				QString fullImageFileName= QFileInfo(m_FileName).absolutePath() + QDir::separator() + QFileInfo(imageFileName).fileName();
				if (QFileInfo(fullImageFileName).exists())
				{
					m_ListOfAttachedFileName << fullImageFileName;
					GLC_Texture* pTexture= new GLC_Texture(fullImageFileName);
					pCurrentMaterial->setTexture(pTexture);
				}
				else
				{
					QStringList stringList(m_FileName);
					stringList.append(imageFileName + " Not found");
					GLC_ErrorLog::addError(stringList);
				}
			}
			else
			{
				QStringList stringList(m_FileName);
				stringList.append(imageFileName + " Not found");
				GLC_ErrorLog::addError(stringList);
			}

		}
		else
		{
			QStringList stringList(m_FileName);
			stringList.append("Texture : " + textureId + " Not found");
			GLC_ErrorLog::addError(stringList);
		}
		++iMat;
	}
}
// Create mesh and link them to material
void GLC_ColladaToWorld::createMesh()
{
	//qDebug() << "GLC_ColladaToWorld::createMesh()";
	QHash<const QString, MeshInfo*>::iterator iMeshInfo= m_GeometryHash.begin();
	while (m_GeometryHash.constEnd() != iMeshInfo)
	{
		MeshInfo* pCurrentMeshInfo= iMeshInfo.value();
		// Add Bulk Data to the mesh
		// Add vertice
		pCurrentMeshInfo->m_pMesh->addVertice(pCurrentMeshInfo->m_Datas.at(VERTEX).toVector());
		//qDebug() << "Add " << pCurrentMeshInfo->m_Datas[VERTEX].size() << " Vertice";
		pCurrentMeshInfo->m_Datas[VERTEX].clear();

		// Add Normal
		pCurrentMeshInfo->m_pMesh->addNormals(pCurrentMeshInfo->m_Datas.at(NORMAL).toVector());
		//qDebug() << "Add " << pCurrentMeshInfo->m_Datas[NORMAL].size() << " Normal";
		pCurrentMeshInfo->m_Datas[NORMAL].clear();

		// Add texel if necessary
		//qDebug() << "Add " << pCurrentMeshInfo->m_Datas[TEXCOORD].size() << " texel";
		if (!pCurrentMeshInfo->m_Datas.at(TEXCOORD).isEmpty())
		{
			pCurrentMeshInfo->m_pMesh->addTexels(pCurrentMeshInfo->m_Datas.at(TEXCOORD).toVector());
			pCurrentMeshInfo->m_Datas[TEXCOORD].clear();
		}

		// Add face index and material to the mesh
		QHash<QString, MatOffsetSize>::iterator iMatInfo= pCurrentMeshInfo->m_Materials.begin();
		while (pCurrentMeshInfo->m_Materials.constEnd() != iMatInfo)
		{
			// Trying to find the material
			QString materialId= iMatInfo.key();
			GLC_Material* pCurrentMaterial= NULL;
			if (m_MaterialInstanceMap.contains(materialId))
			{
				//qDebug() << "Map " << materialId << " to " << m_MaterialInstanceMap.value(materialId);
				materialId= m_MaterialInstanceMap.value(materialId);
			}
			//qDebug() << "MaterialLibHash size : " << m_MaterialLibHash.size();
			if (m_MaterialLibHash.contains(materialId))
			{
				materialId= m_MaterialLibHash.value(materialId);
				//qDebug() << "Material id " << materialId;
			}
			if (m_MaterialEffectHash.contains(materialId))
			{
				//qDebug() << "Material " << materialId << " find";
				pCurrentMaterial= m_MaterialEffectHash.value(materialId);
				Q_ASSERT(NULL != pCurrentMaterial);
			}
			else
			{
				QStringList stringList(m_FileName);
				stringList.append("Material " + materialId + " Not found");
				GLC_ErrorLog::addError(stringList);
			}

			// Create the list of triangles to add to the mesh
			const int offset= iMatInfo.value().m_Offset;
			const int size= iMatInfo.value().m_size;
			//qDebug() << "Offset : " << offset << " size : " << size;
			QList<GLuint> triangles;
			for (int i= offset; i < (offset + size); ++i)
			{
				triangles.append(pCurrentMeshInfo->m_Index.at(i));
			}
			//qDebug() << "Add " << triangles.size() << " elment to the triangle index";
			// Add the list of triangle to the mesh
			if (!triangles.isEmpty())
			{
				pCurrentMeshInfo->m_pMesh->addTriangles(pCurrentMaterial, triangles);
			}

			++iMatInfo;
		}
		pCurrentMeshInfo->m_pMesh->finish();
		GLC_3DRep* pRep= new GLC_3DRep(pCurrentMeshInfo->m_pMesh);
		pCurrentMeshInfo->m_pMesh= NULL;
		pRep->clean();
		//qDebug() << "Insert Rep : " << iMeshInfo.key();
		m_3DRepHash.insert(iMeshInfo.key(), pRep);
		++iMeshInfo;
	}
}

// Create the scene graph struct
void GLC_ColladaToWorld::createSceneGraph()
{
	const int topLevelNodeCount= m_TopLevelColladaNode.size();
	for (int i= 0; i < topLevelNodeCount; ++i)
	{
		ColladaNode* pCurrentColladaNode= m_TopLevelColladaNode.at(i);
		//qDebug() << "Top level node is : " << pCurrentColladaNode->m_Id;
		if (NULL != pCurrentColladaNode)
		{
			GLC_StructOccurence* pOccurence= createOccurenceFromNode(pCurrentColladaNode);
			m_pWorld->rootOccurence()->addChild(pOccurence);
		}
	}

	// Update position
	m_pWorld->rootOccurence()->removeEmptyChildren();
	m_pWorld->rootOccurence()->updateChildrenAbsoluteMatrix();

}

// Create Occurence tree from node tree
GLC_StructOccurence* GLC_ColladaToWorld::createOccurenceFromNode(ColladaNode* pNode)
{
	//qDebug() << "GLC_ColladaToWorld::createOccurenceFromNode";
	Q_ASSERT(NULL != pNode);
	GLC_StructInstance* pInstance= NULL;
	GLC_StructOccurence* pOccurence= NULL;
	if (!pNode->m_InstanceGeometryIDs.isEmpty())
	{
		if (m_StructInstanceHash.contains(pNode->m_Id))
		{
			pInstance= new GLC_StructInstance(m_StructInstanceHash.value(pNode->m_Id));
			pInstance->move(pNode->m_Matrix);
			//qDebug() << "Instance move with this matrix :" << pNode->m_Matrix.toString();
			pOccurence= new GLC_StructOccurence(pInstance);
		}
		else
		{
			const int size= pNode->m_InstanceGeometryIDs.size();
			GLC_3DRep* pRep= NULL;
			for (int i= 0; i < size; ++i)
			{
				const QString geometryId= pNode->m_InstanceGeometryIDs.at(i);
				if (NULL == pRep)
				{
					pRep= new GLC_3DRep(*(m_3DRepHash.value(geometryId)));
				}
				else
				{
					pRep->merge(m_3DRepHash.value(geometryId));
				}
			}
			if (NULL != pRep)
			{
				GLC_StructReference* pStructRef= NULL;
				if (pRep->isEmpty())
				{
					QStringList stringList(m_FileName);
					stringList.append("Empty rep : " + pRep->name());
					GLC_ErrorLog::addError(stringList);
					delete pRep;
					pRep= NULL;
				}
				else
				{
					pStructRef= new GLC_StructReference(pRep);
					pInstance= new GLC_StructInstance(pStructRef);

					// Save instance in instance hash Table
					m_StructInstanceHash.insert(pNode->m_Id, pInstance);

					pInstance->move(pNode->m_Matrix);
					//qDebug() << "Instance move with this matrix :" << pNode->m_Matrix.toString();
					pOccurence= new GLC_StructOccurence(pInstance);
				}

			}
			else
			{
				QStringList stringList(m_FileName);
				stringList.append("Geometry Id Not found");
				GLC_ErrorLog::addError(stringList);
			}
		}
	}
	if (!pNode->m_ChildNodes.isEmpty())
	{
		if (NULL == pOccurence) //  The node hasn't geometry -> Create an occurence
		{
			if (m_StructInstanceHash.contains(pNode->m_Id))
			{
				pInstance= new GLC_StructInstance(m_StructInstanceHash.value(pNode->m_Id));
			}
			else
			{
				GLC_StructReference* pStructRef= new GLC_StructReference(pNode->m_Id);
				pInstance= new GLC_StructInstance(pStructRef);
			}

			pInstance->move(pNode->m_Matrix);
			pOccurence= new GLC_StructOccurence(pInstance);
		}

		const int size= pNode->m_ChildNodes.size();
		for (int i= 0; i < size; ++i)
		{
			if (NULL != pNode->m_ChildNodes.at(i))
			{
				pOccurence->addChild(createOccurenceFromNode(pNode->m_ChildNodes.at(i)));
			}
		}
	}
	if (!pNode->m_InstanceOffNodeIds.isEmpty())
	{
		if (NULL == pOccurence) //  The node hasn't geometry and childs -> Create an occurence
		{
			if (m_StructInstanceHash.contains(pNode->m_Id))
			{
				pInstance= new GLC_StructInstance(m_StructInstanceHash.value(pNode->m_Id));
			}
			else
			{
				GLC_StructReference* pStructRef= new GLC_StructReference(pNode->m_Id);
				pInstance= new GLC_StructInstance(pStructRef);
			}

			pInstance->move(pNode->m_Matrix);
			pOccurence= new GLC_StructOccurence(pInstance);
		}

		const int size= pNode->m_InstanceOffNodeIds.size();
		for (int i= 0; i < size; ++i)
		{
			if (m_ColladaNodeHash.contains(pNode->m_InstanceOffNodeIds.at(i)))
			{
				pOccurence->addChild(createOccurenceFromNode(m_ColladaNodeHash.value(pNode->m_InstanceOffNodeIds.at(i))));
			}
			else
			{
				const QString errorMsg= "Instance Node : " + pNode->m_InstanceOffNodeIds.at(i) + "Not Found";
				throwException(errorMsg);
			}
		}
	}
	if (NULL == pOccurence)
	{
		if (m_StructInstanceHash.contains(pNode->m_Id))
		{
			pInstance= new GLC_StructInstance(m_StructInstanceHash.value(pNode->m_Id));
		}
		else
		{
			GLC_StructReference* pStructRef= new GLC_StructReference(pNode->m_Id);
			pInstance= new GLC_StructInstance(pStructRef);
		}

		pInstance->move(pNode->m_Matrix);
		pOccurence= new GLC_StructOccurence(pInstance);
	}

	return pOccurence;
}

// Update progress bar
void GLC_ColladaToWorld::updateProgressBar()
{
	qint64 currentOffset= m_pStreamReader->characterOffset();

	int currentQuantumValue;
	// Progrees bar indicator
	currentQuantumValue = static_cast<int>((static_cast<double>(currentOffset) / m_FileSize) * 100);
	if (currentQuantumValue > m_CurrentOffset)
	{
		emit currentQuantum(currentQuantumValue);
		m_CurrentOffset= currentQuantumValue;
	}

}
