// Old Lightmap process


void SortFaceByTextureName(vector<CMesh::CFace*> &AllFaces, CMesh::CMeshBuild *pMB)
{
	int i, j;
	int nNbFace = AllFaces.size();

	for( i = 0; i < nNbFace-1; ++i )
	for( j = i+1; j < nNbFace; ++j )
	{
		ITexture *pT = pMB->Materials[AllFaces[i]->MaterialId].getTexture(0);
		CTextureFile *pTF = dynamic_cast<CTextureFile *>(pT);
		string namei = "Default";
		if( pTF != NULL )
			namei = pTF->getFileName();
		pT = pMB->Materials[AllFaces[j]->MaterialId].getTexture(0);
		pTF = dynamic_cast<CTextureFile *>(pT);
		string namej = "Default";
		if( pTF != NULL )
			namej = pTF->getFileName();
		if( namei < namej )
		{
			CMesh::CFace *pFaceTemp = AllFaces[i];
			AllFaces[i] = AllFaces[j];
			AllFaces[j] = pFaceTemp;
		}
	}
}

// TextureNames is an array which indicates the number of faces that follows which have the same texture name
void ComputeAreaOfTextureName(vector<sint32> &TextureNames, vector<CMesh::CFace*> &AllFaces, CMesh::CMeshBuild *pMB)
{
	int i, nNbFace = AllFaces.size();
	TextureNames.resize(nNbFace);
	ITexture *pT = pMB->Materials[AllFaces[0]->MaterialId].getTexture(0);
	CTextureFile *pTF = dynamic_cast<CTextureFile *>(pT);
	string CurrentName = "Default";
	sint32 lastface = 0, nNbTexName = 0;
	if( pTF != NULL )
		CurrentName = pTF->getFileName();
	for( i = 0; i < nNbFace; ++i )
	{
		ITexture *pT = pMB->Materials[AllFaces[i]->MaterialId].getTexture(0);
		CTextureFile *pTF = dynamic_cast<CTextureFile *>(pT);
		string namei = "Default";
		if( pTF != NULL )
			namei = pTF->getFileName();
		if( ( namei != CurrentName ) || ( i == (nNbFace-1) ) )
		{
			CurrentName = namei;
			TextureNames[nNbTexName] = i-lastface;
			nNbTexName++;
			lastface = i;
		}
	}
	TextureNames[nNbTexName-1] += 1;
	TextureNames.resize( nNbTexName );
}

void SortFaceByMaterialId( int offset, int nNbFace, vector<CMesh::CFace*> &AllFaces )
{
	int i, j;
	
	for( i = 0; i < nNbFace-1; ++i )
	for( j = i+1; j < nNbFace; ++j )
	if( AllFaces[offset+i]->MaterialId < AllFaces[offset+j]->MaterialId )
	{
		CMesh::CFace *pFaceTemp = AllFaces[offset+i];
		AllFaces[offset+i] = AllFaces[offset+j];
		AllFaces[offset+j] = pFaceTemp;
	}
}

void SortFaceByTextureSurface( int offset, int nNbFace, vector<CMesh::CFace*> &AllFaces )
{
	int i, j;

	for( i = 0; i < nNbFace-1; ++i )
	for( j = i+1; j < nNbFace; ++j )
	if( AllFaces[i]->MaterialId == AllFaces[j]->MaterialId )
	{
		// Texture surface of the i face = .5*|(u1-u0)*(v2-v0)-(v1-v0)*(u2-u0)|
		// in fact this is lightmap mapping surface
		double surfacei = 0.5*fabs(
		(AllFaces[i]->Corner[1].Uvws[1].U - AllFaces[i]->Corner[0].Uvws[1].U)*
		(AllFaces[i]->Corner[2].Uvws[1].V - AllFaces[i]->Corner[0].Uvws[1].V)-
		(AllFaces[i]->Corner[1].Uvws[1].V - AllFaces[i]->Corner[0].Uvws[1].V)*
		(AllFaces[i]->Corner[2].Uvws[1].U - AllFaces[i]->Corner[0].Uvws[1].U) );
		double surfacej = 0.5*fabs(
		(AllFaces[j]->Corner[1].Uvws[1].U - AllFaces[j]->Corner[0].Uvws[1].U)*
		(AllFaces[j]->Corner[2].Uvws[1].V - AllFaces[j]->Corner[0].Uvws[1].V)-
		(AllFaces[j]->Corner[1].Uvws[1].V - AllFaces[j]->Corner[0].Uvws[1].V)*
		(AllFaces[j]->Corner[2].Uvws[1].U - AllFaces[j]->Corner[0].Uvws[1].U) );
		if( surfacei < surfacej )
		{
			CMesh::CFace *pFaceTemp = AllFaces[i];
			AllFaces[i] = AllFaces[j];
			AllFaces[j] = pFaceTemp;
		}
	}
}

bool isInTriangle(double x, double y, double xt1, double yt1, double xt2, double yt2, double xt3, double yt3)
{
	// Test vecteur T1X avec T1T2
	double sign1 = ((xt2-xt1)*(y-yt1) - (yt2-yt1)*(x-xt1));
	// Test vecteur T2X avec T2T3
	double sign2 = ((xt3-xt2)*(y-yt2) - (yt3-yt2)*(x-xt2));
	// Test vecteur T3X avec T3T1
	double sign3 = ((xt1-xt3)*(y-yt3) - (yt1-yt3)*(x-xt3));
	if( (sign1 <= 0.0)&&(sign2 <= 0.0)&&(sign3 <= 0.0) )
		return true;
	if( (sign1 >= 0.0)&&(sign2 >= 0.0)&&(sign3 >= 0.0) )
		return true;
	return false;
}

// Segment line intersection P1P2 and P3P4
bool segmentIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
	double denominator = (y4-y3)*(x2-x1) - (x4-x3)*(y2-y1);
	double k = ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3) ) / denominator;
	if( (k<0.0) || (k>1.0) ) return false;
	k = ( (x2-x1)*(y1-y3) - (y2-y1)*(x1-x3) ) / denominator;
	if( (k<0.0) || (k>1.0) ) return false;
	return true;
}

void CreatePiece( vector<uint8>& Piece, sint32& nSizeX, sint32& nSizeY, sint32 &nPosX, sint32 &nPosY,
				 float lumx1, float lumy1,
				 float lumx2, float lumy2, 
				 float lumx3, float lumy3, uint8 nCol )
{
	double minx, miny;
	double maxx, maxy;
	int j,k;

	if( nCol == 0 )
		nCol = 1;
	minx = lumx1;
	if( minx > lumx2 ) minx = lumx2;
	if( minx > lumx3 ) minx = lumx3;
	maxx = lumx1;
	if( maxx < lumx2 ) maxx = lumx2;
	if( maxx < lumx3 ) maxx = lumx3;
	miny = lumy1;
	if( miny > lumy2 ) miny = lumy2;
	if( miny > lumy3 ) miny = lumy3;
	maxy = lumy1;
	if( maxy < lumy2 ) maxy = lumy2;
	if( maxy < lumy3 ) maxy = lumy3;

	// Put the piece in the new basis (nPosX,nPosY)
	nPosX = ((sint32)floor(minx-0.5));
	nPosY = ((sint32)floor(miny-0.5));

	lumx1 -= nPosX; lumy1 -= nPosY;
	lumx2 -= nPosX; lumy2 -= nPosY;
	lumx3 -= nPosX;	lumy3 -= nPosY;

	nSizeX = 1 + ((sint32)floor(maxx+0.5)) - ((sint32)floor(minx-0.5));
	nSizeY = 1 + ((sint32)floor(maxy+0.5)) - ((sint32)floor(miny-0.5));
	Piece.resize( nSizeX*nSizeY );
	for( j = 0; j < nSizeX*nSizeY; ++j )
		Piece[j] = 0;

// The square interact with the triangle if an edge of the square is cut by an edge of the triangle
// Or the square is in the triangle
	
	for( j = 0; j < nSizeY-1; ++j )
	for( k = 0; k < nSizeX-1; ++k )
	{
		// Is the square (j,k) is interacting with the triangle
		// This means : The square contains a point of the triangle (can be done for the 3 points)
		//              The triangle contains a point of the square
		// If so then we have to turn on all the 4 pixels of the square
		if( isInTriangle(k+0.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
			isInTriangle(k+1.5,j+0.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
			isInTriangle(k+0.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) ||
			isInTriangle(k+1.5,j+1.5,lumx1,lumy1,lumx2,lumy2,lumx3,lumy3) )
		{
			Piece[k   + j    * nSizeX] = nCol;
			Piece[1+k + j    * nSizeX] = nCol;
			Piece[k   + (1+j)* nSizeX] = nCol;
			Piece[1+k + (1+j)* nSizeX] = nCol;
		}

		if( segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+0.5, j+0.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||

			segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+0.5, j+0.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) ||

			segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+1.5, j+1.5, k+1.5, j+0.5, lumx3, lumy3, lumx1, lumy1) ||

			segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx1, lumy1, lumx2, lumy2) ||
			segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx2, lumy2, lumx3, lumy3) ||
			segmentIntersection(k+1.5, j+1.5, k+0.5, j+1.5, lumx3, lumy3, lumx1, lumy1) )
		{
			Piece[k   + j    * nSizeX] = nCol;
			Piece[1+k + j    * nSizeX] = nCol;
			Piece[k   + (1+j)* nSizeX] = nCol;
			Piece[1+k + (1+j)* nSizeX] = nCol;
		}

	}
	// For all the points of the triangle update the square
	Piece[((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5))*nSizeX] = nCol;
	Piece[1+((sint32)(lumx1-0.5)) + ((sint32)(lumy1-0.5))*nSizeX] = nCol;
	Piece[((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*nSizeX] = nCol;
	Piece[1+((sint32)(lumx1-0.5)) + (1+((sint32)(lumy1-0.5)))*nSizeX] = nCol;

	Piece[((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5))*nSizeX] = nCol;
	Piece[1+((sint32)(lumx2-0.5)) + ((sint32)(lumy2-0.5))*nSizeX] = nCol;
	Piece[((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*nSizeX] = nCol;
	Piece[1+((sint32)(lumx2-0.5)) + (1+((sint32)(lumy2-0.5)))*nSizeX] = nCol;
	
	Piece[((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5))*nSizeX] = nCol;
	Piece[1+((sint32)(lumx3-0.5)) + ((sint32)(lumy3-0.5))*nSizeX] = nCol;
	Piece[((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*nSizeX] = nCol;
	Piece[1+((sint32)(lumx3-0.5)) + (1+((sint32)(lumy3-0.5)))*nSizeX] = nCol;
}

void ResizeBitmap( vector<uint8> &vBitmap, sint32 &nSizeX, sint32 &nSizeY, sint32 nNewSizeX, sint32 nNewSizeY )
{
	vector<uint8> vImgTemp;
	int i, j;

	vImgTemp.resize(nNewSizeX*nNewSizeY);
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		vImgTemp[i] = 0;

	for( j = 0; j < min(nSizeY,nNewSizeY); ++j )
	for( i = 0; i < min(nSizeX,nNewSizeX); ++i )
	{
		vImgTemp[i+j*nNewSizeX] = vBitmap[i+j*nSizeX];
	}

	vBitmap.resize(nNewSizeX*nNewSizeY);
	for( i = 0; i < nNewSizeX*nNewSizeY; ++i )
		vBitmap[i] = vImgTemp[i];

	nSizeX = nNewSizeX;
	nSizeY = nNewSizeY;
}

bool PutPieceInLightMap( vector<uint8>& Piece, sint32 nPieceSizeX, sint32 nPieceSizeY, 
						 vector<uint8>& LightMap, sint32 nLightMapSizeX, sint32 nLightMapSizeY,
						 sint32 &nNewPosX, sint32 &nNewPosY )
{
	sint32 i, j, a, b;
	bool bGoodPosition;

	if( nPieceSizeX > nLightMapSizeX ) return false;
	if( nPieceSizeY > nLightMapSizeY ) return false;

	// For all position test if the piece can get in
	for( j = 0; j < (nLightMapSizeY-nPieceSizeY); ++j )
	for( i = 0; i < (nLightMapSizeX-nPieceSizeX); ++i )
	{
		bGoodPosition = true;
		for( b = 0; b < nPieceSizeY; ++b )
		{
			for( a = 0; a < nPieceSizeX; ++a )
			{
				if( Piece[a+b*nPieceSizeX] != 0 )
					if( LightMap[(i+a)+(j+b)*nLightMapSizeX] != 0 )
					{
						bGoodPosition = false;
						break;
					}
			}
			if( bGoodPosition == false )
				break;
		}
		if( bGoodPosition )
		{
			// Write the piece in the lightmap !!!
			for( b = 0; b < nPieceSizeY; ++b )
			{
				for( a = 0; a < nPieceSizeX; ++a )
				{
					if( Piece[a+b*nPieceSizeX] != 0 )
						LightMap[(i+a)+(j+b)*nLightMapSizeX] = Piece[a+b*nPieceSizeX];
				}
			}
			nNewPosX = i;
			nNewPosY = j;
			return true;
		}
	}

	return false;
}

void MapFace( CMesh::CFace *pFace, vector<CVector> &Vertices, double rRatio )
{
	CVector V01 = Vertices[pFace->Corner[1].Vertex] - Vertices[pFace->Corner[0].Vertex];
	CVector V02 = Vertices[pFace->Corner[2].Vertex] - Vertices[pFace->Corner[0].Vertex];
	CVector n = V01 ^ V02;
	n.normalize();
	
	// Quantize the normal

	// Table of unitary vector with relevant direction to map The I vector represent the plane normal
	// and the J,K vector the U,V vector
	CMatrix QuantizationTbl[3]; 
	QuantizationTbl[0].identity();
	QuantizationTbl[1].identity(); QuantizationTbl[1].rotateZ(Pi/2);
	QuantizationTbl[2].identity(); QuantizationTbl[2].rotateY(Pi/2);

	float fMax = 0.0f;
	int pos = 0;
	for( int i = 0; i < 3; ++i )
	{
		if( fMax < fabs(QuantizationTbl[i].getI()*n) )
		{
			fMax = fabs(QuantizationTbl[i].getI()*n);
			pos = i;
		}
	}

	// Map with the i_th vector from the quantization table
	// Projection of the 3 vertices of the triangle on the plane 
	// defined by the quantized vector (as the plane normal) and the origin (as a point in the plane)

	// This is equivalent to a base changement with annulation of the I vector
	CMatrix invMat = QuantizationTbl[pos].inverted();
	CVector newPtinUVBasis = invMat.mulPoint(Vertices[pFace->Corner[0].Vertex]);
	pFace->Corner[0].Uvws[1].U = newPtinUVBasis.y / rRatio;
	pFace->Corner[0].Uvws[1].V = newPtinUVBasis.z / rRatio;
	newPtinUVBasis = invMat.mulPoint(Vertices[pFace->Corner[1].Vertex]);
	pFace->Corner[1].Uvws[1].U = newPtinUVBasis.y / rRatio;
	pFace->Corner[1].Uvws[1].V = newPtinUVBasis.z / rRatio;
	newPtinUVBasis = invMat.mulPoint(Vertices[pFace->Corner[2].Vertex]);
	pFace->Corner[2].Uvws[1].U = newPtinUVBasis.y / rRatio;
	pFace->Corner[2].Uvws[1].V = newPtinUVBasis.z / rRatio;	
}

CMatrix getObjectToWorldMatrix( CMesh::CMeshBuild *pMB )
{
	CMatrix m1, m2, m3, m4, m5;
	m1.identity();
	m1.setPos( pMB->DefaultPivot );
	m1.invert();

	m2.identity();
	m2.scale( pMB->DefaultScale );

	m3.identity();
	m3.setRot( pMB->DefaultRotQuat );

	m4.identity();
	m4.setPos( pMB->DefaultPivot );

	m5.identity();
	m5.setPos( pMB->DefaultPos );

	m1 = m5*m4*m3*m2*m1;
	
	return m1;
}

float getUVDist( CUV& UV1, CUV& UV2 )
{
	return sqrt( (UV2.U - UV1.U)*(UV2.U - UV1.U) + (UV2.V - UV1.V)*(UV2.V - UV1.V) );
}

struct SLightBuild
{
	enum EType { LightAmbient, LightPoint, LightDir, LightSpot };
	EType Type;
	CVector Position;					// Applicable to LightPoint and LightSpot
	CVector Direction;					// Applicable to LightSpot and LightDir
	float rRadiusMin, rRadiusMax;		// Applicable to LightPoint and LightSpot
	CRGBA Ambient;
	CRGBA Diffuse;
	CRGBA Specular;
	SLightBuild()
	{
		Type = LightPoint;
		Position = CVector(0.0, 0.0, 0.0);
		Direction = CVector(1.0, 0.0, 0.0);
		rRadiusMin = 1.0f;
		rRadiusMax = 2.0f;
		Ambient = CRGBA(0, 0, 0, 0);
		Diffuse = CRGBA(0, 0, 0, 0);
		Specular = CRGBA(0, 0, 0, 0);
	}
};




void getLightBuildList(std::vector<SLightBuild>& vectLight, TimeValue tvTime, Interface& ip, INode*node=NULL )
{
	if( node == NULL )
		node = ip.GetRootNode();

	// Get a pointer on the object's node
    Object *obj = node->EvalWorldState(tvTime).obj;

	// Check if there is an object
	if (obj)
	{
		// Get a GenLight from the node
		if (obj->SuperClassID()==LIGHT_CLASS_ID)
		{
			GenLight *maxLight = (GenLight *) obj;

			bool deleteIt=false;
			if (obj != maxLight) 
				deleteIt = true;

			SLightBuild nelLight;

			// Eval the light state fot this tvTime
			Interval valid=NEVER;
			LightState ls;

			if (maxLight->EvalLightState(tvTime, valid, &ls)==REF_SUCCEED)
			{
				// Set the light mode
				switch (maxLight->Type())
				{
					case OMNI_LIGHT:
						nelLight.Type = SLightBuild::EType::LightPoint;
					break;
					case TSPOT_LIGHT:
					case FSPOT_LIGHT:
						nelLight.Type = SLightBuild::EType::LightSpot;
					break;
					case DIR_LIGHT:
					case TDIR_LIGHT:
						nelLight.Type = SLightBuild::EType::LightDir;
					break;
					default:
						// Not initialized
					break;
				}

				// *** Set the light color

				// Get the color
				CRGBA nelColor;
				Point3 maxColor = maxLight->GetRGBColor(tvTime);

				// Mul by multiply
				CRGBAF nelFColor;
				nelFColor.R = maxColor.x;
				nelFColor.G = maxColor.y;
				nelFColor.B = maxColor.z;
				nelFColor.A = 1.f;
				nelFColor   *= maxLight->GetIntensity(tvTime);
				nelColor = nelFColor;

				// Affect the ambiant color ?
				nelLight.Ambient = nelColor;
				nelLight.Diffuse = CRGBA (0,0,0);
				nelLight.Specular = CRGBA (0,0,0);
				if (maxLight->GetAmbientOnly())
				{
					nelLight.Ambient = nelColor;
				}
				else
				{
					// Affect the diffuse color ?
					if( maxLight->GetAffectDiffuse() )
						nelLight.Diffuse = nelColor;
					// Affect the specular color ?
					if (maxLight->GetAffectSpecular())
						nelLight.Specular = nelColor;
				}

				// Set the light position
				Point3 pos = node->GetNodeTM(tvTime).GetTrans ();
				CVector position;
				position.x=pos.x;
				position.y=pos.y;
				position.z=pos.z;

				// Set the position
				nelLight.Position = position;

				// Set the light direction
				CVector direction;
				INode* target = node->GetTarget ();
				if (target)
				{
					// Get the position of the target
					Point3 posTarget=target->GetNodeTM (tvTime).GetTrans ();
					CVector positionTarget;
					positionTarget.x=posTarget.x;
					positionTarget.y=posTarget.y;
					positionTarget.z=posTarget.z;

					// Direction
					direction=positionTarget-position;
					direction.normalize ();
				}
				else	// No target
				{
					// Get orientation of the source as direction
					CMatrix nelMatrix;
					CExportNel::convertMatrix (nelMatrix, node->GetNodeTM(tvTime));

					// Direction is -Z
					direction=-nelMatrix.getK();
					direction.normalize ();
				}

				// Set the direction
				nelLight.Direction = direction;
				/*
				// Set spot light information
				nelLight.setCutoff ((float)(NLMISC::Pi*maxLight.GetFallsize(tvTime)/180.f/2.f));

				// Compute the exponent value
				float angle=(float)(NLMISC::Pi*maxLight.GetHotspot(tvTime)/(2.0*180.0));
				nelLight.setupSpotExponent (angle);

				// *** Set attenuation

				if (maxLight.GetUseAtten())
					nelLight.setupAttenuation (maxLight.GetAtten (tvTime, ATTEN_START), maxLight.GetAtten (tvTime, ATTEN_END));
				else
					nelLight.setNoAttenuation ();
				*/
				if (maxLight->GetUseAtten())
				{
					nelLight.rRadiusMin = maxLight->GetAtten (tvTime, ATTEN_START);
					nelLight.rRadiusMax = maxLight->GetAtten (tvTime, ATTEN_END);
				}
				// Add the light in the list
				vectLight.push_back (nelLight);
			}
			if( deleteIt )
				delete maxLight;
		}
	}

	// Recurse sub node
	for (int i=0; i<node->NumberOfChildren(); i++)
		getLightBuildList(vectLight, tvTime, ip, node->GetChildNode(i));
}

void getLightBuilds( vector<SLightBuild> &lights, TimeValue tvTime, Interface& ip )
{
	SLightBuild amb;

	amb.Type = SLightBuild::EType::LightAmbient;
	amb.Ambient.R = (uint8)(ip.GetAmbient( tvTime, FOREVER ).x*255);
	amb.Ambient.G = (uint8)(ip.GetAmbient( tvTime, FOREVER ).y*255);
	amb.Ambient.B = (uint8)(ip.GetAmbient( tvTime, FOREVER ).z*255);
	amb.Ambient.A = 255;
	amb.Specular = amb.Diffuse = CRGBA(0,0,0,0);
	lights.push_back( amb );
	getLightBuildList( lights, tvTime, ip );

}


// -----------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------
bool CNelExport::exportScene(std::vector<INode*>& vectNode)
{
	// All inputs are transfered throught the global theExportSceneStruct structure

	// Export the Instance Group (aka scene description)
	// *************************
	if( theExportSceneStruct.bExportInstanceGroup )
		exportInstanceGroup( theExportSceneStruct.sExportInstanceGroup, vectNode );

	// Export all the shapes
	// *********************
	// If lighting enabled we export the shape after lightmapping modification
	if( theExportSceneStruct.bExportShapes && (!theExportSceneStruct.bExportLighting) )
	{
		// Get time
		TimeValue tvTime = theCNelExport.ip->GetTime();

		// Get node count
		int nNumSelNode = vectNode.size();

		// Save all selected objects
		for (int nNode=0; nNode<nNumSelNode; nNode++)
		{
			// Get the node
			INode* pNode=vectNode[nNode];

			// It is a zone ?
			if (RPO::isZone (*pNode, tvTime))
			{
				// Nothing to do if this is a zone
			}
			// Try to export a mesh
			else if (CExportNel::isMesh (*pNode, tvTime))
			{
				// Build the name of the file to export
				char sSavePath[512];
				strcpy( sSavePath, theExportSceneStruct.sExportShapes.c_str() );
				if(theExportSceneStruct.sExportShapes[theExportSceneStruct.sExportShapes.size()-1] != '\\' )
					strcat( sSavePath, "\\" );
				strcat( sSavePath, pNode->GetName() );
				strcat( sSavePath, ".shape" );

				// Export the mesh
				if (!theCNelExport.exportMesh (sSavePath, *pNode, *theCNelExport.ip, tvTime))
				{
					// Error message
					char sErrorMsg[512];
					sprintf (sErrorMsg, "Error exporting the mesh %s in the file\n%s", pNode->GetName(), sSavePath);
					MessageBox (theCNelExport.ip->GetMAXHWnd(), sErrorMsg, "NeL export scene", MB_OK|MB_ICONEXCLAMATION );
				}
			}
		}
	}

	// Export the lighting (aka compute all light maps)
	// *******************
	#define RATIOLIGHTMAP	0.05		// 0.5 meters in real world represent 1 Lumel in UV world
	#define MAXLIGHTMAPSIZE 1024
	if( theExportSceneStruct.bExportLighting )
	{
		// 1 -> Build all MeshBuild structure
		// ----------------------------------
		vector< pair < CMesh::CMeshBuild*,INode* > > AllMeshBuilds;
		TimeValue tvTime = theCNelExport.ip->GetTime();
		int nNumSelNode = vectNode.size();
		int nNbMesh = 0;
		int nNode, i, j, k;
		// Count number of mesh in the selection
		for( nNode = 0; nNode < nNumSelNode; ++nNode )
		{
			INode* pNode = vectNode[nNode];
			if( ! RPO::isZone( *pNode, tvTime ) )
			if( CExportNel::isMesh( *pNode, tvTime ) )
				nNbMesh++;
		}
		AllMeshBuilds.resize(nNbMesh);
		nNbMesh = 0;
		// Create all the MeshBuild used to place lightmaps and to raytrace lightmaps
		for( nNode=0; nNode < nNumSelNode; ++nNode )
		{
			INode* pNode = vectNode[nNode];
			if( ! RPO::isZone( *pNode, tvTime ) )
			if( CExportNel::isMesh( *pNode, tvTime ) )
			{
				AllMeshBuilds[nNbMesh].second = pNode;
				AllMeshBuilds[nNbMesh].first = CExportNel::createMeshBuild( *pNode, tvTime );
				nNbMesh++;
			}
		}
		// 2 -> Place lightmap for all MeshBuild (this operation does not need interaction between MeshBuilds)
		for( nNode=0; nNode < nNbMesh; ++nNode )
		{
			// First order face by Material and by texture surface
			CMesh::CMeshBuild *pMB = AllMeshBuilds[nNode].first;
			CMatrix MBMatrix = getObjectToWorldMatrix( pMB );
			vector<CMesh::CFace*> AllFaces;
			vector<CVector> AllVertices; // All vertices in world space
			vector<sint32> AreaTextureNames; // Number of faces with the same texture name
			sint32 nNbFace = pMB->Faces.size(), nNbVertex = pMB->Vertices.size();
			sint32 offset, nNewPosX, nNewPosY;
			// Make a vector of pointer to all the faces of the MeshBuild
			AllFaces.resize(nNbFace);
			for( i = 0; i < nNbFace; ++i )
				AllFaces[i] = &pMB->Faces[i];
			AllVertices.resize(nNbVertex);
			for( i = 0; i < nNbVertex; ++i )
				AllVertices[i] = MBMatrix * pMB->Vertices[i];
			// Bubble sort pointer to the faces (Material sorting by texture name)
			SortFaceByTextureName( AllFaces, pMB );
			// Get the number of faces in Allfaces for each different texture name
			ComputeAreaOfTextureName( AreaTextureNames, AllFaces, pMB );

			// For all faces that has the same texture name
			offset = 0;
			for( int nTexName = 0; nTexName < AreaTextureNames.size(); ++nTexName )
			{
				nNbFace = AreaTextureNames[nTexName];
				// Bubble sort pointer to the faces (Material sorting)
				SortFaceByMaterialId( offset, nNbFace, AllFaces );
				// Sort by texture surface if the faces have the same material
				SortFaceByTextureSurface( offset, nNbFace, AllFaces );
				offset += nNbFace;
			}
			
			// Here is the placement
			// TEST 1 : One all big lightmap for this object
			//sint32 CurrentMaterialId = AllFaces[0]->MaterialId;
			//sint32 BeginningFace = 0;
			vector<uint8> TheLightMap;
			sint32 nLightMapSizeX = 1, nLightMapSizeY = 1;
			TheLightMap.resize(1);
			nNbFace = pMB->Faces.size();
			// Calculation of the texture ratio
			double SpaceDist = 0.0, TextureDist = 0.0;
			for( i = 0; i < nNbFace; ++i )
			{
				CVector v = AllVertices[AllFaces[i]->Corner[1].Vertex] - AllVertices[AllFaces[i]->Corner[0].Vertex];
				SpaceDist += v.norm();
				v = AllVertices[AllFaces[i]->Corner[2].Vertex] - AllVertices[AllFaces[i]->Corner[1].Vertex];
				SpaceDist += v.norm();
				v = AllVertices[AllFaces[i]->Corner[0].Vertex] - AllVertices[AllFaces[i]->Corner[2].Vertex];
				SpaceDist += v.norm();
				TextureDist += getUVDist( AllFaces[i]->Corner[1].Uvws[1], AllFaces[i]->Corner[0].Uvws[1] );
				TextureDist += getUVDist( AllFaces[i]->Corner[2].Uvws[1], AllFaces[i]->Corner[1].Uvws[1] );
				TextureDist += getUVDist( AllFaces[i]->Corner[0].Uvws[1], AllFaces[i]->Corner[2].Uvws[1] );
			}
			double LMTextRatio = SpaceDist / TextureDist;
			LMTextRatio = LMTextRatio / RATIOLIGHTMAP;

			for( i = 0; i < nNbFace; ++i )
			{
				// Piece creation
				vector<uint8> Piece;
				sint32 nPieceSizeX, nPieceSizeY;				
				// Try to map this face with quantized vector and express uv in lumel
				// MapFace( AllFaces[i], AllVertices, RATIOLIGHTMAP );
				for( j = 0; j < 3; ++j ) // Express the UVs in lumel with a ratio
				{	// For each corner
					AllFaces[i]->Corner[j].Uvws[1].U *= LMTextRatio;
					AllFaces[i]->Corner[j].Uvws[1].V *= LMTextRatio;
				}
				// Create the related piece
				CreatePiece( Piece, nPieceSizeX, nPieceSizeY, nNewPosX, nNewPosY,
							 AllFaces[i]->Corner[0].Uvws[1].U,	// lumx1
							 AllFaces[i]->Corner[0].Uvws[1].V,	// lumy1
							 AllFaces[i]->Corner[1].Uvws[1].U,	// lumx2
							 AllFaces[i]->Corner[1].Uvws[1].V,	// lumy2
							 AllFaces[i]->Corner[2].Uvws[1].U,	// lumx3
							 AllFaces[i]->Corner[2].Uvws[1].V,	// lumy3
							 (i%254)+1 ); // color
				// Set the UV of the face in same basis as the piece (0->nPieceSize)
				for( j = 0; j < 3; ++j )
				{	// For each corner
					AllFaces[i]->Corner[j].Uvws[1].U -= nNewPosX;
					AllFaces[i]->Corner[j].Uvws[1].V -= nNewPosY;
				}

				while( true )
				{
					if( !PutPieceInLightMap( Piece, nPieceSizeX, nPieceSizeY, 
											 TheLightMap, nLightMapSizeX, nLightMapSizeY,
											 nNewPosX, nNewPosY ) )
					{
						if( ( nLightMapSizeX < MAXLIGHTMAPSIZE ) || ( nLightMapSizeY < MAXLIGHTMAPSIZE ) )
						{
							if( nLightMapSizeX < nLightMapSizeY )
								ResizeBitmap( TheLightMap, nLightMapSizeX, nLightMapSizeY, nLightMapSizeX*2, nLightMapSizeY );
							else
								ResizeBitmap( TheLightMap, nLightMapSizeX, nLightMapSizeY, nLightMapSizeX, nLightMapSizeY*2 );
						}
						else
						{
							// ERROR: we reached the maximum texture size
							nlstop;
						}
					}
					else
					{
						// We found a position for this piece, update texture coord in lumel format
						for( j = 0; j < 3; ++j )
						{
							AllFaces[i]->Corner[j].Uvws[1].U += nNewPosX;
							AllFaces[i]->Corner[j].Uvws[1].V += nNewPosY;
						}
						break;
					}
				}
			}
			// All faces have been put in the lightmap so update All texture coord with the size of the lightmap
			// Convert all faces from lumels to lumels/sizeofLightMap to get uv from 0.0 to 1.0
			for( i = 0; i < nNbFace; ++i )
			for( j = 0; j < 3; ++j )
			{
				AllFaces[i]->Corner[j].Uvws[1].U /= nLightMapSizeX;
				AllFaces[i]->Corner[j].Uvws[1].V /= nLightMapSizeY;
			}
			// Write the new lightmap and update the buildmesh materials
			{
				CTextureFile *pTexture = new CTextureFile;
				string sTemp = AllMeshBuilds[nNode].second->GetName();
				sTemp += ".tga";
				pTexture->setFileName( sTemp );
				sTemp = theExportSceneStruct.sExportLighting;
				if(sTemp[sTemp.size()-1] != '\\' ) sTemp += "\\";
				sTemp += AllMeshBuilds[nNode].second->GetName();
				sTemp += ".tga";
				pTexture->resize( nLightMapSizeX, nLightMapSizeY );
				CObjectVector<uint8> &rText = pTexture->getPixels();
				for( j = 0; j < nLightMapSizeY; ++j )
				for( i = 0; i < nLightMapSizeX; ++i )
					if( TheLightMap[i+j*nLightMapSizeX] != 0 )
					{
						rText[(i+j*nLightMapSizeX)*4+0] = 63+((TheLightMap[i+j*nLightMapSizeX]*15)%190);
						rText[(i+j*nLightMapSizeX)*4+1] = 63+((TheLightMap[i+j*nLightMapSizeX]*27+63)%190);
						rText[(i+j*nLightMapSizeX)*4+2] = 63+((TheLightMap[i+j*nLightMapSizeX]*13+127)%190);
						rText[(i+j*nLightMapSizeX)*4+3] = 255;
					}
					else
					{
						rText[(i+j*nLightMapSizeX)*4+0] = 0;
						rText[(i+j*nLightMapSizeX)*4+1] = 0;
						rText[(i+j*nLightMapSizeX)*4+2] = 0;
						rText[(i+j*nLightMapSizeX)*4+3] = 0;
					}
				// Write texture to disk
				//{
				//	COFile f;
				//	f.open( sTemp );
				//	pTexture->writeTGA( f, 32 );
				//}
				for( i = 0; i < AllMeshBuilds[nNode].first->Materials.size(); ++i )
				{
					AllMeshBuilds[nNode].first->Materials[i].setTexture( 1, pTexture );
					//AllMeshBuilds[nNode].first->Materials[i].setLighting( false );
				}
			}
		} // End for all nodes
		// All nodes are mapped correctly with a lightmap and lightmap is created on disk
		// --------
		// RAYTRACE the scene
		// --------
		// 0 - Get Lights from 3DSMAX
		vector<SLightBuild> vLights;
		getLightBuilds( vLights, tvTime, *theCNelExport.ip );
// Old version (with lighting for the Nel Core Engine)
//		vector<CLight> vLights;
//		CExportNel::getLights( vLights, tvTime, *theCNelExport.ip );

		// 1 - Light with the normal and the lights
		for( nNode=0; nNode < nNbMesh; ++nNode )
		{
			CMesh::CMeshBuild *pMB = AllMeshBuilds[nNode].first;
			CMatrix MBMatrix = getObjectToWorldMatrix( pMB );
			vector<CVector> AllVertices; // All vertices in world space

			AllVertices.resize(pMB->Vertices.size());
			for( i = 0; i < pMB->Vertices.size(); ++i )
				AllVertices[i] = MBMatrix * pMB->Vertices[i];

			// Select all lights that interact with this mesh
			
			sint32 nNbFace = pMB->Faces.size();
			MBMatrix.invert();
			MBMatrix.transpose();
			for( i = 0; i < nNbFace; ++i )
			{
				vector<uint8> Piece;
				sint32 nPieceSizeX, nPieceSizeY, nPiecePosX, nPiecePosY;
				// Get the lightmap from the material of the face
				ITexture *pText = pMB->Materials[pMB->Faces[i].MaterialId].getTexture( 1 );
				CTextureFile *pLightMap = dynamic_cast<CTextureFile*>(pText);
				if( pLightMap == NULL )
					continue;
				double	u1 = pMB->Faces[i].Corner[0].Uvws[1].U * pLightMap->getWidth(),
						v1 = pMB->Faces[i].Corner[0].Uvws[1].V * pLightMap->getHeight(),
						u2 = pMB->Faces[i].Corner[1].Uvws[1].U * pLightMap->getWidth(), 
						v2 = pMB->Faces[i].Corner[1].Uvws[1].V * pLightMap->getHeight(),
						u3 = pMB->Faces[i].Corner[2].Uvws[1].U * pLightMap->getWidth(), 
						v3 = pMB->Faces[i].Corner[2].Uvws[1].V * pLightMap->getHeight();
				CVector p1 = AllVertices[pMB->Faces[i].Corner[0].Vertex],
						p2 = AllVertices[pMB->Faces[i].Corner[1].Vertex],
						p3 = AllVertices[pMB->Faces[i].Corner[2].Vertex];
				CVector n1 = MBMatrix.mulVector( pMB->Faces[i].Corner[0].Normal ),
						n2 = MBMatrix.mulVector( pMB->Faces[i].Corner[1].Normal ),
						n3 = MBMatrix.mulVector( pMB->Faces[i].Corner[2].Normal );
				n1.normalize(); n2.normalize(); n3.normalize();
				// Denominator Gradient along u and v
				double GradDen = 1.0 / ( (u3-u1)*(v2-v1) - (u2-u1)*(v3-v1) );

				// Get the mask
				CreatePiece( Piece, nPieceSizeX, nPieceSizeY, nPiecePosX, nPiecePosY,
							 u1, v1, u2, v2, u3, v3, 1 );
				// Parse the mask
				for( k = 0; k < nPieceSizeY; ++k )
				for( j = 0; j < nPieceSizeX; ++j )
				if( Piece[j+k*nPieceSizeX] != 0 ) // Must this point be lighted ?
				{	// Yes
					CRGBAF theColor;
					// Convert the (u,v) to world space coord (use gradient of x along u and v) (same for y,z...)
					double theU = nPiecePosX + j + 0.5;
					double theV = nPiecePosY + k + 0.5;
					CVector p, n; // p is the point in the world space

					double GradU = ( (p3.x-p1.x)*(v2-v1)-(p2.x-p1.x)*(v3-v1) ) * GradDen;
					double GradV = ( (p2.x-p1.x)*(u3-u1)-(p3.x-p1.x)*(u2-u1) ) * GradDen;
					p.x = GradU*(theU-u1) + GradV*(theV-v1) + p1.x;

					GradU = ( (p3.y-p1.y)*(v2-v1)-(p2.y-p1.y)*(v3-v1) ) * GradDen;
					GradV = ( (p2.y-p1.y)*(u3-u1)-(p3.y-p1.y)*(u2-u1) ) * GradDen;
					p.y = GradU*(theU-u1) + GradV*(theV-v1) + p1.y;

					GradU = ( (p3.z-p1.z)*(v2-v1)-(p2.z-p1.z)*(v3-v1) ) * GradDen;
					GradV = ( (p2.z-p1.z)*(u3-u1)-(p3.z-p1.z)*(u2-u1) ) * GradDen;
					p.z = GradU*(theU-u1) + GradV*(theV-v1) + p1.z;

					// The same for the normal
					
					GradU = ( (n3.x-n1.x)*(v2-v1)-(n2.x-n1.x)*(v3-v1) ) * GradDen;
					GradV = ( (n2.x-n1.x)*(u3-u1)-(n3.x-n1.x)*(u2-u1) ) * GradDen;
					n.x = GradU*(theU-u1) + GradV*(theV-v1) + n1.x;

					GradU = ( (n3.y-n1.y)*(v2-v1)-(n2.y-n1.y)*(v3-v1) ) * GradDen;
					GradV = ( (n2.y-n1.y)*(u3-u1)-(n3.y-n1.y)*(u2-u1) ) * GradDen;
					n.y = GradU*(theU-u1) + GradV*(theV-v1) + n1.y;

					GradU = ( (n3.z-n1.z)*(v2-v1)-(n2.z-n1.z)*(v3-v1) ) * GradDen;
					GradV = ( (n2.z-n1.z)*(u3-u1)-(n3.z-n1.z)*(u2-u1) ) * GradDen;
					n.z = GradU*(theU-u1) + GradV*(theV-v1) + n1.z;
					
					// --- n = n1 + n2 + n3;
					n.normalize();

					
					theColor.R = theColor.G = theColor.B = theColor.A = 0.0;
					// Color calculation
					for( sint32 nLight = 0; nLight < vLights.size(); ++nLight )
					{
						SLightBuild rLight = vLights[nLight];
						CRGBAF lightAmbiCol = CRGBAF(0.0, 0.0, 0.0, 0.0);
						CRGBAF lightDiffCol = CRGBAF(0.0, 0.0, 0.0, 0.0);
						CRGBAF lightSpecCol = CRGBAF(0.0, 0.0, 0.0, 0.0);

						switch( rLight.Type )
						{
							case SLightBuild::LightAmbient:
								lightAmbiCol.R = rLight.Ambient.R / 255.0;
								lightAmbiCol.G = rLight.Ambient.G / 255.0;
								lightAmbiCol.B = rLight.Ambient.B / 255.0;
								lightAmbiCol.A = rLight.Ambient.A / 255.0;
							break;
							case SLightBuild::LightPoint:
							{
								CVector p_light = rLight.Position - p;
								double p_light_distance = p_light.norm();
								double light_intensity;
								if( p_light_distance < rLight.rRadiusMin )
									light_intensity = 1.0;
								else
								if( p_light_distance > rLight.rRadiusMax )
									light_intensity = 0.0;
								else
									light_intensity = 1.0 - (p_light_distance-rLight.rRadiusMin)/(rLight.rRadiusMax-rLight.rRadiusMin);
								p_light.normalize();

								// ??? light_intensity *= light_intensity * light_intensity;
								lightDiffCol.R = light_intensity * rLight.Diffuse.R * max(0.0f, n*p_light) / 255.0;
								lightDiffCol.G = light_intensity * rLight.Diffuse.G * max(0.0f, n*p_light) / 255.0;
								lightDiffCol.B = light_intensity * rLight.Diffuse.B * max(0.0f, n*p_light) / 255.0;
								lightDiffCol.A = light_intensity * rLight.Diffuse.A * max(0.0f, n*p_light) / 255.0;
							}
							break;
							case SLightBuild::LightDir:
							{
								CVector light = - rLight.Direction;
								light.normalize();
								lightDiffCol.R = rLight.Diffuse.R * max(0.0f, n*light) / 255.0;
								lightDiffCol.G = rLight.Diffuse.G * max(0.0f, n*light) / 255.0;
								lightDiffCol.B = rLight.Diffuse.B * max(0.0f, n*light) / 255.0;
								lightDiffCol.A = rLight.Diffuse.A * max(0.0f, n*light) / 255.0;
							}
							break;
							case SLightBuild::LightSpot:
								// TODO
							break;
							default:
							break;
						}
						theColor.R += lightAmbiCol.R + lightDiffCol.R;// * matDiffCol.R;
						if( theColor.R > 1.0 ) theColor.R = 1.0;
						theColor.G += lightAmbiCol.G + lightDiffCol.G;// * matDiffCol.G;
						if( theColor.G > 1.0 ) theColor.G = 1.0;
						theColor.B += lightAmbiCol.B + lightDiffCol.B;// * matDiffCol.B;
						if( theColor.B > 1.0 ) theColor.B = 1.0;
						theColor.A += lightAmbiCol.A + lightDiffCol.A;// * matDiffCol.A;
						if( theColor.A > 1.0 ) theColor.A = 1.0;
					}					
					// Affect the color

		theColor.R = (1+n.x)/2;
		theColor.G = (1+n.y)/2;
		theColor.B = (1+n.z)/2;
		theColor.A = 1.;

					CObjectVector<uint8> &pixel = pLightMap->getPixels();
					pixel[(j+nPiecePosX + (k+nPiecePosY)*pLightMap->getWidth())*4+0] = theColor.R*255;
					pixel[(j+nPiecePosX + (k+nPiecePosY)*pLightMap->getWidth())*4+1] = theColor.G*255;
					pixel[(j+nPiecePosX + (k+nPiecePosY)*pLightMap->getWidth())*4+2] = theColor.B*255;
					pixel[(j+nPiecePosX + (k+nPiecePosY)*pLightMap->getWidth())*4+3] = theColor.A*255;
				}				
			}
			// Write the new LightMap
			{
				COFile f;
				ITexture *pText = pMB->Materials[0].getTexture( 1 );
				CTextureFile *pLightMap = dynamic_cast<CTextureFile*>(pText);
				string sTemp = theExportSceneStruct.sExportLighting;
				if(sTemp[sTemp.size()-1] != '\\' ) sTemp += "\\";
				sTemp += pLightMap->getFileName();
				f.open( sTemp );
				pLightMap->writeTGA( f, 32 );
			}

		}

		// End of the lighting process for this node we have to export the data
		for( nNode=0; nNode < nNbMesh; ++nNode )
		{
			// First order face by Material and by texture surface
			CMesh::CMeshBuild *pMB = AllMeshBuilds[nNode].first;
			CMesh* mesh = new CMesh;
			pMB->VertexFlags |= CVertexBuffer::TexCoord1Flag;
			// Build the mesh with the build interface

			// TEMP YOYO (DU) DE SA RACE
			pMB->VertexFlags |= CVertexBuffer::PrimaryColorFlag;
			CMatrix MBMatrix = getObjectToWorldMatrix( pMB );
			for( i = 0; i < pMB->Faces.size(); ++i )			
			{
				CVector n = MBMatrix.mulVector(pMB->Faces[i].Corner[0].Normal);
				pMB->Faces[i].Corner[0].Color.R = 255.0 * (n.x+1.0)/2.0;
				pMB->Faces[i].Corner[0].Color.G = 255.0 * (n.y+1.0)/2.0;
				pMB->Faces[i].Corner[0].Color.B = 255.0 * (n.z+1.0)/2.0;
				pMB->Faces[i].Corner[0].Color.A = 255.0;
				n = MBMatrix.mulVector(pMB->Faces[i].Corner[1].Normal);
				pMB->Faces[i].Corner[1].Color.R = 255.0 * (n.x+1.0)/2.0;
				pMB->Faces[i].Corner[1].Color.G = 255.0 * (n.y+1.0)/2.0;
				pMB->Faces[i].Corner[1].Color.B = 255.0 * (n.z+1.0)/2.0;
				pMB->Faces[i].Corner[1].Color.A = 255.0;
				n = MBMatrix.mulVector(pMB->Faces[i].Corner[2].Normal);
				pMB->Faces[i].Corner[2].Color.R = 255.0 * (n.x+1.0)/2.0;
				pMB->Faces[i].Corner[2].Color.G = 255.0 * (n.y+1.0)/2.0;
				pMB->Faces[i].Corner[2].Color.B = 255.0 * (n.z+1.0)/2.0;
				pMB->Faces[i].Corner[2].Color.A = 255.0;
			}
			// TEMP YOYO (DU) DE SA RACE end

			for( i = 0; i < pMB->Materials.size(); ++i )
			{
				pMB->Materials[i].setLighting( false );
				pMB->Materials[i].setColor( CRGBA(255,255,255,255) );
			}
			// *** TMP : force material to be animatable
			// TODO: check if material are animated
			//for (uint i=0; i<buildMesh.Materials.size(); i++)
			//{
			//	mesh->setAnimatedMaterial (i, materialNames[i]);
			//}

			mesh->build( *pMB );


			COFile file;
			char sSavePath[512];
			strcpy( sSavePath, theExportSceneStruct.sExportShapes.c_str() );
			if(theExportSceneStruct.sExportShapes[theExportSceneStruct.sExportShapes.size()-1] != '\\' )
				strcat( sSavePath, "\\" );
			strcat( sSavePath, AllMeshBuilds[nNode].second->GetName() );
			strcat( sSavePath, ".shape" );
			if (file.open( sSavePath ))
			{
				try
				{
					// Create a streamable shape
					CShapeStream shapeStream( mesh );
					// Serial the shape
					shapeStream.serial (file);
				}
				catch (...)
				{
				}
			}

			// Delete the pointer
			delete mesh;
		}

		// ? -> Ending deletion des objets temporaires
		for( nNode = 0; nNode < nNbMesh; ++nNode )
			delete AllMeshBuilds[nNode].first;
	} // End if lighting process asked

	return true;
}