//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

//
//

//General Includes
//
#include <maya/MIOStream.h>
#include <maya/MGlobal.h>
#include <maya/MDagPath.h>
#include <maya/MIntArray.h>
#include <maya/MFnSet.h>
#include <maya/MItDependencyGraph.h>
#include <maya/MPlug.h>

//Iterator Includes
//
#include <maya/MItMeshPolygon.h>

//polyX3DWriter.cpp
#include "polyX3DWriter.h"


//Macros

//used as the default color for vertices which have no color assigned
//
#define DEFAULT_COLOR	"0.2 0.2 0.2"

//used as default values for the Material tag when outputting a texture
//
#define DIFFUSE_COLOR	"0 0 0"
#define SHININESS		"0.8"
#define SPECULAR_COLOR	"0.5 0.5 0.5"

//flags used to indicate which tags have been outputted already, so to
//minimize data duplication
//
#define COORDINATE_FLAG 0x0001
#define NORMAL_FLAG		0x0010
#define TEXTURE_FLAG	0x0100
#define COLOR_FLAG		0x1000

//number of spaces per tab
#define INITIAL_TAB_COUNT 2

polyX3DWriter::polyX3DWriter(const MDagPath& dagPath, MStatus& status):
	polyWriter(dagPath, status),
	fTagFlags(0),
	fInitialTabCount(INITIAL_TAB_COUNT)
//Summary:	creates and initializes an object of this class
//Args   :	dagPath - the DAG path of the current node
//			status - will be set to MStatus::kSuccess if the constructor was
//					 successful;  MStatus::kFailure otherwise
{
}


polyX3DWriter::~polyX3DWriter()
{
//Summary:  destructor method - does nothing
//
}


MStatus polyX3DWriter::extractGeometry() 
//Summary:	extracts main geometry as well as the current UV set and UV set 
//			coordinates
{
	if (MStatus::kFailure == polyWriter::extractGeometry()) {
		return MStatus::kFailure;
	}

	if (MStatus::kFailure == fMesh->getUVs(fUArray, fVArray, &fCurrentUVSetName)) {
		MGlobal::displayError("MFnMesh::getUVs"); 
		return MStatus::kFailure;
	}

	return MStatus::kSuccess;
}


MStatus polyX3DWriter::writeToFile(ostream& os) 
//Summary:	outputs the geometry of this polygonal mesh in X3D compliant format
//Args   :	os - an output stream to write to
//			tabCount - the initial number of tabs to print
//Returns:  MStatus::kSuccess if the method succeeds
//			MStatus::kFailure if the method fails
{
	MGlobal::displayInfo("Exporting " + fMesh->partialPathName());
	unsigned int setCount = fPolygonSets.length();

	if (0 == setCount) {
		return MStatus::kFailure;
	} else if (1 == setCount) {
		if (MStatus::kFailure == outputSets(os)) {
			return MStatus::kFailure;
		}
	} else {
		outputTabs(os, INITIAL_TAB_COUNT);
		fInitialTabCount++;
		os << "<Group DEF=\"" << fMesh->partialPathName() << "\">\n";
		if (MStatus::kFailure == outputSets(os)) {
			return MStatus::kFailure;
		}
		outputTabs(os, INITIAL_TAB_COUNT);
		os << "</Group>\n";
	}
	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputSingleSet (ostream& os, MString setName, MIntArray faces, MString textureName) {
//Summary:	outputs a single set of polygons grouped under a Shape tag
//Args   :	os - an output stream to write to
//			shapeName - the value for the DEF attribute
//			faces - an MIntArray containing the indices of the faces to include
//					in this shape
//			textureName - the full path for the texture file
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
	if (0 == fPolygonSets.length()) {
		return MStatus::kFailure;
	} else if (1 == fPolygonSets.length()) {
		setName = fMesh->partialPathName();
	} else {
		setName = fMesh->partialPathName() + "_" + setName;
	}
	return outputX3DShapeTag (os, setName, faces, textureName, fInitialTabCount);
}


MStatus polyX3DWriter::outputX3DShapeTag(ostream & os,
									 const MString shapeName,
									 const MIntArray& faces,
									 const MString textureName,
									 const unsigned int tabCount) 
//Summary:	outputs the X3D Shape tag with the DEF attribute
//Args   :	os - an output stream to write to
//			shapeName - the value for the DEF attribute
//			faces - an MIntArray containing the indices of the faces to include
//					in this shape
//			textureName - the full path for the texture file
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	outputTabs(os, tabCount);
	os << "<Shape DEF=\"" << shapeName << "\">\n";

	if (MStatus::kFailure == outputX3DAppearanceTag(os, textureName, tabCount + 1)) { 
		return MStatus::kFailure;
	}

	if (MStatus::kFailure == outputX3DIndexedFaceSetTag(os, faces, textureName, tabCount + 1)) {
		return MStatus::kFailure;
	}

	outputTabs(os, tabCount);
	os << "</Shape>\n";

	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DAppearanceTag(ostream & os, 
										  const MString textureName, 
										  const unsigned int tabCount) 
//Summary:	outputs the X3D Appearance Tag.  If textureName is an empty string, 
//			outputs the default Material tag;  otherwise outputs a Material tag 
//			with diffuseColor, shininess, and specularColor values set, along 
//			with an ImageTexture tag with the url attribute value set to 
//			textureName
//Args   :	os - an output stream to write to
//			textureName - the full path of the texture file
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	outputTabs(os, tabCount);

	//No texture name given, output default apperance and material tags
	//
	if (textureName == MString("")) {
		os << "<Appearance><Material/></Appearance>\n";

	//Texture name was given, output an ImageTexture tag with the texture name 
	//as the value of the url attribute, and output default values for the 
	//diffuseColor, shininess, and specularColor of the material node
	//
	} else {
		os << "<Appearance>\n";
		outputTabs(os, tabCount + 1);
		os << "<ImageTexture url=\"" << textureName << "\"/>\n";
		outputTabs(os, tabCount + 1);
		os << "<Material diffuseColor=\"" << DIFFUSE_COLOR 
		   << "\" shininess=\"" << SHININESS 
		   << "\" specularColor=\"" << SPECULAR_COLOR 
		   << "\"/>\n";
		outputTabs(os, tabCount);
		os << "</Appearance>\n";
	}
	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DIndexedFaceSetTag(ostream & os, 
											  const MIntArray& faces,
											  const MString textureName, 
											  const unsigned int tabCount) 
//Summary:	outputs the X3D IndexedFaceSet tag along with the Coordinate and
//			Normal tags.  If textureName is an empty string, also outputs the
//			Color tag and IndexedFaceSet's colorIndex and colorPerVertex 
//			attributes; otherwise outputs the TextureCoordinate tag and
//			IndexedFaceSet's texCoordIndex attribute
//Args   :	os - an output stream to write to
//			faces - an MIntArray containing the indices of the faces to include
//					in this IndexedFaceSet
//			textureName - the full path for the texture file
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	outputTabs(os, tabCount);
	os << "<IndexedFaceSet coordIndex=\"";

	unsigned int faceCount = faces.length();

	//if there are no faces to output return an error status
	//
	if (0 == faceCount) {
		return MStatus::kFailure;
	}

	MStatus status;
	//general purpose counters
	//
	unsigned int i, j, indexCount;

	//general int array storage
	//
	MIntArray indexList;

	//For every face in the faces array, retrieve and output its vertices.
	//getPolygonVertices() returns the indices of the vertices of a given face,
	//and orders the vertex indices in the array in the manner required for the
	//X3D IndexedFaceSet tag.  Note, these indices refer to the array fVertexArray.
	//
	for (i = 0; i < faceCount; i++) {

		indexCount = fMesh->polygonVertexCount(faces[i], &status);
		if (MStatus::kFailure == status) {
			MGlobal::displayError("MFnMesh::polygonVertexCount");
			return MStatus::kFailure;
		}

		//store those vertices for face[i] and output them
		//
		status = fMesh->getPolygonVertices (faces[i], indexList);
		if (MStatus::kFailure == status) {
			MGlobal::displayError("MFnMesh::getPolygonVertices");
			return MStatus::kFailure;
		}

		for (j = 0; j < indexCount; j++) {
			os << indexList[j] << " ";
		}

		os << "-1 ";
	}

	//For every face in the faces array, retrieve and output its vertex normals.
	//getNormalIDs() returns the indices of the normals of a given face.  Note, 
	//these indices refer to the array fNormalArray.
	//
	os << "\" normalPerVertex=\"true\" normalIndex=\"";
	for (i = 0; i < faceCount; i++) {
		//store the vertex normals for face[i]
		//
		status = fMesh->getFaceNormalIds (faces[i], indexList);
		if (MStatus::kFailure == status) {
			MGlobal::displayError("MFnMesh::getFaceNormalIds");
			return MStatus::kFailure;
		}

		//determine the number of vertex normals for face[i] 
		//and output them
		indexCount = indexList.length();
		for (j = 0; j < indexCount; j++) {
			os << indexList[j] << " ";
		}
		os << "-1 ";
	}
	os << "\" ";

	//If a texture name is not given, output colorIndex attribute
	if (textureName == MString("")) {
		os << "colorPerVertex=\"true\" ";
		//output the color indices for each per polygon vertex.  These indices
		//refer to the array fColorArray
		//
		os << "colorIndex=\"";
		int colorIndex = 0;
		for (i = 0; i < faceCount; i++) {
			indexCount = fMesh->polygonVertexCount(faces[i], &status);
			if (MStatus::kFailure == status) {
				MGlobal::displayError("MFnMesh::polygonVertexCount");
				return MStatus::kFailure;
			}

			for (j = 0; j < indexCount; j++) {
				if (MStatus::kFailure == fMesh->getFaceVertexColorIndex(faces[i], j, colorIndex)) {
					MGlobal::displayError("MFnMesh::getFaceVertexColorIndex");
					return MStatus::kFailure;
				}
				os << colorIndex << " ";
			}
			os << "-1 ";
		}
		os << "\">\n";

		//output the X3D color tag to correspond with the indices
		//
		if (MStatus::kFailure == outputX3DColorTag(os, tabCount + 1)) {
			return MStatus::kFailure;
		}

	//A texture name was given, output the texCoordIndex attribute
	//
	} else {
		os << " texCoordIndex=\"";

		//output the uv indicies for each polygon per vertex.  These indices
		//refer to the arrays fUArray and fVArray
		//
		

		for (i = 0; i < faceCount; i++) {
			indexCount = fMesh->polygonVertexCount(faces[i], &status);
			if (MStatus::kFailure == status) {
				MGlobal::displayError("MFnMesh::polygonVertexCount");
				return MStatus::kFailure;
			}

			for (j = 0; j < indexCount; j++) {
				int uvID;
				status = fMesh->getPolygonUVid(faces[i], j, uvID, &fCurrentUVSetName);
				if (MStatus::kFailure == status) {
					MGlobal::displayError("MFnMesh::getPolygonUVid");
					return MStatus::kFailure;
				}
				os << uvID << " ";
			}
			os << "-1 ";
		}

		os << "\">\n";

		//output the X3D TextureCoordinateTag to correspond with the indices
		//
		if (MStatus::kFailure == outputX3DTextureCoordinateTag(os, tabCount + 1)) {
			return MStatus::kFailure;
		}
	}

	//output the vertex coordinates using the X3D Coordinate tag and
	//output the vertex normals using the X3D Normal tag
	//
	if (MStatus::kFailure == outputX3DCoordinateTag(os, tabCount + 1)
		|| MStatus::kFailure == outputX3DNormalTag(os, tabCount + 1)) {
		return MStatus::kFailure;
	}
	
	outputTabs(os, tabCount);
	os << "</IndexedFaceSet>\n";

	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DCoordinateTag(ostream & os, 
										  const unsigned int tabCount) 
//Summary:	outputs the X3D Coordinate tag with the DEF attribute if the tag 
//			has not been previously output for this polygonal mesh; with the 
//			USE attribute otherwise
//Args   :	os - an output stream to write to
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	unsigned int vertexCount = fVertexArray.length();
	if (0 == vertexCount) {
		return MStatus::kFailure;
	}

	outputTabs(os, tabCount);
	//tag has already been output for this mesh, so just re-use that tag
	//
	if (fTagFlags & COORDINATE_FLAG) {
		os << "<Coordinate USE=\"" << fMesh->partialPathName() << "_coordinates";
	//tag has not been output for this mesh, so define a new tag with the
	//necessary data
	//
	} else {
		fTagFlags |= COORDINATE_FLAG;
		os << "<Coordinate DEF=\"" << fMesh->partialPathName() << "_coordinates\" point=\"";
		unsigned int i;
		for (i = 0; i < vertexCount; i++) {
			os << fVertexArray[i].x << " " 
			   << fVertexArray[i].y << " " 
			   << fVertexArray[i].z << ", ";
		}
	}

	os << "\"/>\n";

	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DNormalTag(ostream & os, 
									  const unsigned int tabCount) 
//Summary:	outputs the X3D Normal tag with the DEF attribute if the Normal tag
//			has not been previously output for this polygonal mesh; with the 
//			USE attribute otherwise
//Args   :	os - an output stream to write to
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	unsigned int normalCount = fNormalArray.length();
	if (0 == normalCount) {
		return MStatus::kFailure;
	}

	outputTabs(os, tabCount);
	//tag has already been output for this mesh, so just re-use that tag
	//
	if (fTagFlags & NORMAL_FLAG) {
		os << "<Normal USE=\"" << fMesh->partialPathName() << "_normals";
	//tag has not been output for this mesh, so define a new tag with the
	//necessary data
	//
	} else {
		fTagFlags |= NORMAL_FLAG;
		os << "<Normal DEF=\"" << fMesh->partialPathName() << "_normals\" vector=\"";
		unsigned int i;
		for (i = 0; i < normalCount; i++) {
			os << fNormalArray[i].x << " " 
			   << fNormalArray[i].y << " " 
			   << fNormalArray[i].z << ", ";
		}
	}
	os << "\"/>\n";

	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DTextureCoordinateTag(ostream & os, 
												 const unsigned int tabCount) 
//Summary:	outputs the X3D TextureCoordinate tag with the DEF attribute if the 
//			tag has not been previously output for this polygonal mesh; with 
//			the USE attribute otherwise
//Args   :	os - an output stream to write to
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	unsigned int uvCount = fUArray.length();
	if (0 == uvCount) {
		return MStatus::kFailure;
	}

	outputTabs(os, tabCount);
	//tag has already been output for this mesh, so just re-use that tag
	//
	if (fTagFlags & TEXTURE_FLAG) {
		os << "<TextureCoordinate USE=\"" << fMesh->partialPathName() << "_texCoordinates";
	//tag has not been output for this mesh, so define a new tag with the
	//necessary data
	//
	} else {
		fTagFlags |= TEXTURE_FLAG;
		os << "<TextureCoordinate DEF=\"" << fMesh->partialPathName() << "_texCoordinates\" point=\"";
		unsigned int i;
		for (i = 0; i < uvCount; i++) {
			os << fUArray[i] << " " << fVArray[i] << ", ";
		}
	}
	os << "\"/>\n";

	return MStatus::kSuccess;
}


MStatus polyX3DWriter::outputX3DColorTag(ostream & os, 
									 const unsigned int tabCount) 
//Summary:	outputs the X3D Color tag with the DEF attribute if the tag has not 
//			been previously output for this polygonal mesh; with the USE 
//			attribute otherwise
//Args   :	os - an output stream to write to
//			tabCount - the number of tabs to preceed this tag
//Returns:  MStatus::kSuccess if the method successfully outputs this tag;
//			MStatus::kFailure otherwise
{
	unsigned int colorCount = fColorArray.length();
	if (0 == colorCount) {
		return MStatus::kFailure;
	}
	
	outputTabs(os, tabCount);
	//tag has already been output for this mesh, so just re-use that tag
	//
	if (fTagFlags & COLOR_FLAG) {
		os << "<Color USE=\"" << fMesh->partialPathName() << "_colors";
	//tag has not been output for this mesh, so define a new tag with the
	//necessary data
	//
	} else {
		fTagFlags |= COLOR_FLAG;
		os << "<Color DEF=\"" << fMesh->partialPathName() << "_colors\" color=\"";
		unsigned int i;
		for (i = 0; i < colorCount; i++) {
			//an rgb value of -1 -1 -1 in Maya indicates no color, so if any
			//component is not -1, color info is present.  Note: only need to check
			//r, g, or b; r was chosen arbitrarily
			//
			if (-1 != fColorArray[i].r) {
				os << fColorArray[i].r << " " 
				   << fColorArray[i].g << " " 
				   << fColorArray[i].b << ", ";
			//use default coloring
			//
			} else {
				os << DEFAULT_COLOR << ", ";
			}
		}
	}
	os << "\"/>\n";

	return MStatus::kSuccess;
}