/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

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

Doom 3 Source Code 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../idlib/precompiled.h"
#pragma hdrstop

#include "Model_ma.h"

/*
======================================================================

	Parses Maya ASCII files.

======================================================================
*/
	

#define MA_VERBOSE( x ) { if ( maGlobal.verbose ) { common->Printf x ; } }

// working variables used during parsing
typedef struct {
	bool			verbose;
	maModel_t		*model;
	maObject_t		*currentObject;
} ma_t;

static ma_t maGlobal;


void MA_ParseNodeHeader(idParser& parser, maNodeHeader_t* header) {

	memset(header, 0, sizeof(maNodeHeader_t));

	idToken token;
	while(parser.ReadToken(&token)) {
		if(!token.Icmp("-")) {
			parser.ReadToken(&token);
			if (!token.Icmp("n")) {
				parser.ReadToken(&token);
				strcpy(header->name, token.c_str());
			} else if (!token.Icmp("p")) {
				parser.ReadToken(&token);
				strcpy(header->parent, token.c_str());
			}
		} else if (!token.Icmp(";")) {
			break;
		}
	}
}

bool MA_ParseHeaderIndex(maAttribHeader_t* header, int& minIndex, int& maxIndex, const char* headerType, const char* skipString) {
	
	idParser miniParse;
	idToken token;

	miniParse.LoadMemory(header->name, strlen(header->name), headerType);
	if(skipString) {
		miniParse.SkipUntilString(skipString);
	}

	if(!miniParse.SkipUntilString("[")) {
		//This was just a header
		return false;
	}
	minIndex = miniParse.ParseInt();
	miniParse.ReadToken(&token);
	if(!token.Icmp("]")) {
		maxIndex = minIndex;
	} else {
		maxIndex = miniParse.ParseInt();
	}
	return true;
}

bool MA_ParseAttribHeader(idParser &parser, maAttribHeader_t* header) {
	
	idToken token;

	memset(header, 0, sizeof(maAttribHeader_t));

	parser.ReadToken(&token);
	if(!token.Icmp("-")) {
		parser.ReadToken(&token);
		if (!token.Icmp("s")) {
			header->size = parser.ParseInt();
			parser.ReadToken(&token);
		}
	}
	strcpy(header->name, token.c_str());
	return true;
}

bool MA_ReadVec3(idParser& parser, idVec3& vec) {
	idToken token;
	if(!parser.SkipUntilString("double3")) {
		throw idException( va("Maya Loader '%s': Invalid Vec3", parser.GetFileName()) );
		return false;
	}


	//We need to flip y and z because of the maya coordinate system
	vec.x = parser.ParseFloat();
	vec.z = parser.ParseFloat();
	vec.y = parser.ParseFloat();

	return true;
}

bool IsNodeComplete(idToken& token) {
	if(!token.Icmp("createNode") || !token.Icmp("connectAttr") || !token.Icmp("select")) {
		return true;
	}
	return false;
}

bool MA_ParseTransform(idParser& parser) {

	maNodeHeader_t	header;
	maTransform_t*	transform;
	memset(&header, 0, sizeof(header));

	//Allocate room for the transform
	transform = (maTransform_t *)Mem_Alloc( sizeof( maTransform_t ) );
	memset(transform, 0, sizeof(maTransform_t));
	transform->scale.x = transform->scale.y = transform->scale.z = 1;

	//Get the header info from the transform
	MA_ParseNodeHeader(parser, &header);

	//Read the transform attributes
	idToken token;
	while(parser.ReadToken(&token)) {
		if(IsNodeComplete(token)) {
			parser.UnreadToken(&token);
			break;
		}
		if(!token.Icmp("setAttr")) {
			parser.ReadToken(&token);
			if(!token.Icmp(".t")) {
				if(!MA_ReadVec3(parser, transform->translate)) {
					return false;
				}
				transform->translate.y *=  -1;
			} else if (!token.Icmp(".r")) {
				if(!MA_ReadVec3(parser, transform->rotate)) {
					return false;
				}
			} else if (!token.Icmp(".s")) {
				if(!MA_ReadVec3(parser, transform->scale)) {
					return false;
				}
			} else {
				parser.SkipRestOfLine();
			}
		}
	}

	if(header.parent[0] != 0) {
		//Find the parent
		maTransform_t**	parent;
		maGlobal.model->transforms.Get(header.parent, &parent);
		if(parent) {
			transform->parent = *parent;
		}
	}
	
	//Add this transform to the list
	maGlobal.model->transforms.Set(header.name, transform);
	return true;
}

bool MA_ParseVertex(idParser& parser, maAttribHeader_t* header) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//Allocate enough space for all the verts if this is the first attribute for verticies
	if(!pMesh->vertexes) {
		pMesh->numVertexes = header->size;
		pMesh->vertexes = (idVec3 *)Mem_Alloc( sizeof( idVec3 ) * pMesh->numVertexes );
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "VertexHeader", NULL)) { 
		//This was just a header
		return true;
	}
	
	//Read each vert
	for(int i = minIndex; i <= maxIndex; i++) {
		pMesh->vertexes[i].x = parser.ParseFloat();
		pMesh->vertexes[i].z = parser.ParseFloat();
		pMesh->vertexes[i].y = -parser.ParseFloat();
	}
	
	return true;
}

bool MA_ParseVertexTransforms(idParser& parser, maAttribHeader_t* header) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//Allocate enough space for all the verts if this is the first attribute for verticies
	if(!pMesh->vertTransforms) {
		if(header->size == 0) {
			header->size = 1;
		}

		pMesh->numVertTransforms = header->size;
		pMesh->vertTransforms = (idVec4 *)Mem_Alloc( sizeof( idVec4 ) * pMesh->numVertTransforms );
		pMesh->nextVertTransformIndex = 0;
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "VertexTransformHeader", NULL)) {
		//This was just a header
		return true;
	}

	parser.ReadToken(&token);
	if(!token.Icmp("-")) {
		idToken tk2;
		parser.ReadToken(&tk2);
		if(!tk2.Icmp("type")) {
			parser.SkipUntilString("float3");
		} else {
			parser.UnreadToken(&tk2);
			parser.UnreadToken(&token);
		}
	} else {
		parser.UnreadToken(&token);
	}

	//Read each vert
	for(int i = minIndex; i <= maxIndex; i++) {
		pMesh->vertTransforms[pMesh->nextVertTransformIndex].x = parser.ParseFloat();
		pMesh->vertTransforms[pMesh->nextVertTransformIndex].z = parser.ParseFloat();
		pMesh->vertTransforms[pMesh->nextVertTransformIndex].y = -parser.ParseFloat();

		//w hold the vert index
		pMesh->vertTransforms[pMesh->nextVertTransformIndex].w = i;

		pMesh->nextVertTransformIndex++;
	}

	return true;
}

bool MA_ParseEdge(idParser& parser, maAttribHeader_t* header) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//Allocate enough space for all the verts if this is the first attribute for verticies
	if(!pMesh->edges) {
		pMesh->numEdges = header->size;
		pMesh->edges = (idVec3 *)Mem_Alloc( sizeof( idVec3 ) * pMesh->numEdges );
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "EdgeHeader", NULL)) {
		//This was just a header
		return true;
	}

	//Read each vert
	for(int i = minIndex; i <= maxIndex; i++) {
		pMesh->edges[i].x = parser.ParseFloat();
		pMesh->edges[i].y = parser.ParseFloat();
		pMesh->edges[i].z = parser.ParseFloat();
	}

	return true;
}

bool MA_ParseNormal(idParser& parser, maAttribHeader_t* header) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//Allocate enough space for all the verts if this is the first attribute for verticies
	if(!pMesh->normals) {
		pMesh->numNormals = header->size;
		pMesh->normals = (idVec3 *)Mem_Alloc( sizeof( idVec3 ) * pMesh->numNormals );
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "NormalHeader", NULL)) {
		//This was just a header
		return true;
	}

	
	parser.ReadToken(&token);
	if(!token.Icmp("-")) {
		idToken tk2;
		parser.ReadToken(&tk2);
		if(!tk2.Icmp("type")) {
			parser.SkipUntilString("float3");
		} else {
			parser.UnreadToken(&tk2);
			parser.UnreadToken(&token);
		}
	} else {
		parser.UnreadToken(&token);
	}
	

	//Read each vert
	for(int i = minIndex; i <= maxIndex; i++) {
		pMesh->normals[i].x = parser.ParseFloat();

		//Adjust the normals for the change in coordinate systems
		pMesh->normals[i].z = parser.ParseFloat();
		pMesh->normals[i].y = -parser.ParseFloat();

		pMesh->normals[i].Normalize();

	}

	pMesh->normalsParsed = true;
	pMesh->nextNormal = 0;

	return true;
}



bool MA_ParseFace(idParser& parser, maAttribHeader_t* header) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//Allocate enough space for all the verts if this is the first attribute for verticies
	if(!pMesh->faces) {
		pMesh->numFaces = header->size;
		pMesh->faces = (maFace_t *)Mem_Alloc( sizeof( maFace_t ) * pMesh->numFaces );
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "FaceHeader", NULL)) {
		//This was just a header
		return true;
	}

	//Read the face data
	int currentFace = minIndex-1;
	while(parser.ReadToken(&token)) {
		if(IsNodeComplete(token)) {
			parser.UnreadToken(&token);
			break;
		}

		if(!token.Icmp("f")) {
			int count = parser.ParseInt();
			if(count != 3) {
				throw idException(va("Maya Loader '%s': Face is not a triangle.", parser.GetFileName()));
				return false;
			}
			//Increment the face number because a new face always starts with an "f" token
			currentFace++;

			//We cannot reorder edges until later because the normal processing
			//assumes the edges are in the original order
			pMesh->faces[currentFace].edge[0] = parser.ParseInt();
			pMesh->faces[currentFace].edge[1] = parser.ParseInt();
			pMesh->faces[currentFace].edge[2] = parser.ParseInt();

			//Some more init stuff
			pMesh->faces[currentFace].vertexColors[0] = pMesh->faces[currentFace].vertexColors[1] = pMesh->faces[currentFace].vertexColors[2] = -1;

		} else if(!token.Icmp("mu")) {
			int uvstIndex = parser.ParseInt();
			int count = parser.ParseInt();
			if(count != 3) {
				throw idException(va("Maya Loader '%s': Invalid texture coordinates.", parser.GetFileName()));
				return false;
			}
			pMesh->faces[currentFace].tVertexNum[0] = parser.ParseInt();
			pMesh->faces[currentFace].tVertexNum[1] = parser.ParseInt();
			pMesh->faces[currentFace].tVertexNum[2] = parser.ParseInt();

		} else if(!token.Icmp("mf")) {
			int count = parser.ParseInt();
			if(count != 3) {
				throw idException(va("Maya Loader '%s': Invalid texture coordinates.", parser.GetFileName()));
				return false;
			}
			pMesh->faces[currentFace].tVertexNum[0] = parser.ParseInt();
			pMesh->faces[currentFace].tVertexNum[1] = parser.ParseInt();
			pMesh->faces[currentFace].tVertexNum[2] = parser.ParseInt();

		} else if(!token.Icmp("fc")) {

			int count = parser.ParseInt();
			if(count != 3) {
				throw idException(va("Maya Loader '%s': Invalid vertex color.", parser.GetFileName()));
				return false;
			}
			pMesh->faces[currentFace].vertexColors[0] = parser.ParseInt();
			pMesh->faces[currentFace].vertexColors[1] = parser.ParseInt();
			pMesh->faces[currentFace].vertexColors[2] = parser.ParseInt();

		}
	}

	return true;
}

bool MA_ParseColor(idParser& parser, maAttribHeader_t* header) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//Allocate enough space for all the verts if this is the first attribute for verticies
	if(!pMesh->colors) {
		pMesh->numColors = header->size;
		pMesh->colors = (byte *)Mem_Alloc( sizeof( byte ) * pMesh->numColors * 4 );
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "ColorHeader", NULL)) {
		//This was just a header
		return true;
	}

	//Read each vert
	for(int i = minIndex; i <= maxIndex; i++) {
		pMesh->colors[i*4] = parser.ParseFloat() * 255;
		pMesh->colors[i*4+1] = parser.ParseFloat() * 255;
		pMesh->colors[i*4+2] = parser.ParseFloat() * 255;
		pMesh->colors[i*4+3] = parser.ParseFloat() * 255;
	}

	return true;
}

bool MA_ParseTVert(idParser& parser, maAttribHeader_t* header) {
	
	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	idToken token;

	//This is not the texture coordinates. It is just the name so ignore it
	if(strstr(header->name, "uvsn")) {
		return true;
	}

	//Allocate enough space for all the data
	if(!pMesh->tvertexes) {
		pMesh->numTVertexes = header->size;
		pMesh->tvertexes = (idVec2 *)Mem_Alloc( sizeof( idVec2 ) * pMesh->numTVertexes );
	}

	//Get the start and end index for this attribute
	int minIndex, maxIndex;
	if(!MA_ParseHeaderIndex(header, minIndex, maxIndex, "TextureCoordHeader", "uvsp")) {
		//This was just a header
		return true;
	}

	parser.ReadToken(&token);
	if(!token.Icmp("-")) {
		idToken tk2;
		parser.ReadToken(&tk2);
		if(!tk2.Icmp("type")) {
			parser.SkipUntilString("float2");
		} else {
			parser.UnreadToken(&tk2);
			parser.UnreadToken(&token);
		}
	} else {
		parser.UnreadToken(&token);
	}

	//Read each tvert
	for(int i = minIndex; i <= maxIndex; i++) {
		pMesh->tvertexes[i].x = parser.ParseFloat();
		pMesh->tvertexes[i].y = 1.0f - parser.ParseFloat();
	}

	return true;
}



/*
*	Quick check to see if the vert participates in a shared normal
*/
bool MA_QuickIsVertShared(int faceIndex, int vertIndex) {
	
	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	int vertNum = pMesh->faces[faceIndex].vertexNum[vertIndex];
	
	for( int i = 0; i < 3; i++) {
		int edge = pMesh->faces[faceIndex].edge[i];
		if(edge < 0) {
			edge = idMath::Fabs(edge)-1;
		}
		if(pMesh->edges[edge].z == 1 && (pMesh->edges[edge].x == vertNum || pMesh->edges[edge].y == vertNum)) {
			return true;
		}
	}
	return false;
}

void MA_GetSharedFace(int faceIndex, int vertIndex, int& sharedFace, int& sharedVert) {

	maMesh_t* pMesh = &maGlobal.currentObject->mesh;
	int vertNum = pMesh->faces[faceIndex].vertexNum[vertIndex];

	sharedFace = -1;
	sharedVert = -1;

	//Find a shared edge on this face that contains the specified vert
	for(int edgeIndex = 0; edgeIndex < 3; edgeIndex++) {

		int edge = pMesh->faces[faceIndex].edge[edgeIndex];
		if(edge < 0) {
			edge = idMath::Fabs(edge)-1;
		}

		if(pMesh->edges[edge].z == 1 && (pMesh->edges[edge].x == vertNum || pMesh->edges[edge].y == vertNum)) {

			for(int i = 0; i < faceIndex; i++) {

				for(int j = 0; j < 3; j++) {
					if(pMesh->faces[i].vertexNum[j] == vertNum) {
						sharedFace = i;
						sharedVert = j;
						break;
					}
				}
			}
		}
		if(sharedFace != -1)
			break;

	}
}

void MA_ParseMesh(idParser& parser) {

	maObject_t	*object;
	object = (maObject_t *)Mem_Alloc( sizeof( maObject_t ) );
	memset( object, 0, sizeof( maObject_t ) );
	maGlobal.model->objects.Append( object );
	maGlobal.currentObject = object;
	object->materialRef = -1;


	//Get the header info from the mesh
	maNodeHeader_t	header;
	MA_ParseNodeHeader(parser, &header);

	//Find my parent
	if(header.parent[0] != 0) {
		//Find the parent
		maTransform_t**	parent;
		maGlobal.model->transforms.Get(header.parent, &parent);
		if(parent) {
			maGlobal.currentObject->mesh.transform = *parent;
		}
	}

	strcpy(object->name, header.name);

	//Read the transform attributes
	idToken token;
	while(parser.ReadToken(&token)) {
		if(IsNodeComplete(token)) {
			parser.UnreadToken(&token);
			break;
		}
		if(!token.Icmp("setAttr")) {
			maAttribHeader_t header;
			MA_ParseAttribHeader(parser, &header);

			if(strstr(header.name, ".vt")) {
				MA_ParseVertex(parser, &header);
			} else if (strstr(header.name, ".ed")) {
				MA_ParseEdge(parser, &header);
			} else if (strstr(header.name, ".pt")) {
				MA_ParseVertexTransforms(parser, &header);
			} else if (strstr(header.name, ".n")) {
				MA_ParseNormal(parser, &header);
			} else if (strstr(header.name, ".fc")) {
				MA_ParseFace(parser, &header);
			} else if (strstr(header.name, ".clr")) {
				MA_ParseColor(parser, &header);
			} else if (strstr(header.name, ".uvst")) {
				MA_ParseTVert(parser, &header);
			} else {
				parser.SkipRestOfLine();
			}
		}
	}


	maMesh_t* pMesh = &maGlobal.currentObject->mesh;

	//Get the verts from the edge
	for(int i = 0; i < pMesh->numFaces; i++) {
		for(int j = 0; j < 3; j++) {
			int edge = pMesh->faces[i].edge[j];
			if(edge < 0) {
				edge = idMath::Fabs(edge)-1;
				pMesh->faces[i].vertexNum[j] = pMesh->edges[edge].y;
			} else {
				pMesh->faces[i].vertexNum[j] = pMesh->edges[edge].x;
			}
		}
	}

	//Get the normals
	if(pMesh->normalsParsed) {
		for(int i = 0; i < pMesh->numFaces; i++) {
			for(int j = 0; j < 3; j++) {

				//Is this vertex shared
				int sharedFace = -1;
				int sharedVert = -1;

				if(MA_QuickIsVertShared(i, j)) {
					MA_GetSharedFace(i, j, sharedFace, sharedVert);
				}
				
				if(sharedFace != -1) {
					//Get the normal from the share
					pMesh->faces[i].vertexNormals[j] = pMesh->faces[sharedFace].vertexNormals[sharedVert];

				} else {
					//The vertex is not shared so get the next normal
					if(pMesh->nextNormal >= pMesh->numNormals) {
						//We are using more normals than exist
						throw idException(va("Maya Loader '%s': Invalid Normals Index.", parser.GetFileName()));
					}
					pMesh->faces[i].vertexNormals[j] = pMesh->normals[pMesh->nextNormal];
					pMesh->nextNormal++;
				}
			}
		}
	}

	//Now that the normals are good...lets reorder the verts to make the tris face the right way
	for(int i = 0; i < pMesh->numFaces; i++) {
			int tmp = pMesh->faces[i].vertexNum[1];
			pMesh->faces[i].vertexNum[1] = pMesh->faces[i].vertexNum[2];
			pMesh->faces[i].vertexNum[2] = tmp;
			
			idVec3 tmpVec = pMesh->faces[i].vertexNormals[1];
			pMesh->faces[i].vertexNormals[1] = pMesh->faces[i].vertexNormals[2];
			pMesh->faces[i].vertexNormals[2] = tmpVec;

			tmp = pMesh->faces[i].tVertexNum[1];
			pMesh->faces[i].tVertexNum[1] = pMesh->faces[i].tVertexNum[2];
			pMesh->faces[i].tVertexNum[2] = tmp;

			tmp = pMesh->faces[i].vertexColors[1];
			pMesh->faces[i].vertexColors[1] = pMesh->faces[i].vertexColors[2];
			pMesh->faces[i].vertexColors[2] = tmp;
	}

	//Now apply the pt transformations
	for(int i = 0; i < pMesh->numVertTransforms; i++) {
		pMesh->vertexes[(int)pMesh->vertTransforms[i].w] +=  pMesh->vertTransforms[i].ToVec3();
	}
	
	MA_VERBOSE((va("MESH %s - parent %s\n", header.name, header.parent)));
	MA_VERBOSE((va("\tverts:%d\n",maGlobal.currentObject->mesh.numVertexes)));
	MA_VERBOSE((va("\tfaces:%d\n",maGlobal.currentObject->mesh.numFaces)));
}

void MA_ParseFileNode(idParser& parser) {
	
	//Get the header info from the node
	maNodeHeader_t	header;
	MA_ParseNodeHeader(parser, &header);

	//Read the transform attributes
	idToken token;
	while(parser.ReadToken(&token)) {
		if(IsNodeComplete(token)) {
			parser.UnreadToken(&token);
			break;
		}
		if(!token.Icmp("setAttr")) {
			maAttribHeader_t attribHeader;
			MA_ParseAttribHeader(parser, &attribHeader);

			if(strstr(attribHeader.name, ".ftn")) {
				parser.SkipUntilString("string");
				parser.ReadToken(&token);
				if(!token.Icmp("(")) {
					parser.ReadToken(&token);
				}

				maFileNode_t* fileNode;
				fileNode = (maFileNode_t*)Mem_Alloc( sizeof( maFileNode_t ) );
				strcpy(fileNode->name, header.name);
				strcpy(fileNode->path, token.c_str());

				maGlobal.model->fileNodes.Set(fileNode->name, fileNode);
			} else {
				parser.SkipRestOfLine();
			}
		}
	}
}

void MA_ParseMaterialNode(idParser& parser) {

	//Get the header info from the node
	maNodeHeader_t	header;
	MA_ParseNodeHeader(parser, &header);

	maMaterialNode_t* matNode;
	matNode = (maMaterialNode_t*)Mem_Alloc( sizeof( maMaterialNode_t ) );
	memset(matNode, 0, sizeof(maMaterialNode_t));

	strcpy(matNode->name, header.name);
	
	maGlobal.model->materialNodes.Set(matNode->name, matNode);
}

void MA_ParseCreateNode(idParser& parser) {

	idToken token;
	parser.ReadToken(&token);

	if(!token.Icmp("transform")) {
		MA_ParseTransform(parser);
	} else if(!token.Icmp("mesh")) {
		MA_ParseMesh(parser);
	} else if(!token.Icmp("file")) {
		MA_ParseFileNode(parser);
	} else if(!token.Icmp("shadingEngine") || !token.Icmp("lambert") || !token.Icmp("phong") || !token.Icmp("blinn") ) {
		MA_ParseMaterialNode(parser);
	}
}


int MA_AddMaterial(const char* materialName) {
	

	maMaterialNode_t**	destNode;
	maGlobal.model->materialNodes.Get(materialName, &destNode);
	if(destNode) {
		maMaterialNode_t* matNode = *destNode;

		//Iterate down the tree until we get a file
		while(matNode && !matNode->file) {
			matNode = matNode->child;
		}
		if(matNode && matNode->file) {
			
			//Got the file
			maMaterial_t	*material;
			material = (maMaterial_t *)Mem_Alloc( sizeof( maMaterial_t ) );
			memset( material, 0, sizeof( maMaterial_t ) );
			
			//Remove the OS stuff
			idStr qPath;
			qPath = fileSystem->OSPathToRelativePath( matNode->file->path );
			
			strcpy(material->name, qPath.c_str());

			maGlobal.model->materials.Append( material );
			return maGlobal.model->materials.Num()-1;
		}
	}
	return -1;
}

bool MA_ParseConnectAttr(idParser& parser) {

	idStr temp;
	idStr srcName;
	idStr srcType;
	idStr destName;
	idStr destType;

	idToken token;
	parser.ReadToken(&token);
	temp = token;
	int dot = temp.Find(".");
	if(dot == -1) {
		throw idException(va("Maya Loader '%s': Invalid Connect Attribute.", parser.GetFileName()));
		return false;
	}
	srcName = temp.Left(dot);
	srcType = temp.Right(temp.Length()-dot-1);

	parser.ReadToken(&token);
	temp = token;
	dot = temp.Find(".");
	if(dot == -1) {
		throw idException(va("Maya Loader '%s': Invalid Connect Attribute.", parser.GetFileName()));
		return false;
	}
	destName = temp.Left(dot);
	destType = temp.Right(temp.Length()-dot-1);

	if(srcType.Find("oc") != -1) {
		
		//Is this attribute a material node attribute
		maMaterialNode_t**	matNode;
		maGlobal.model->materialNodes.Get(srcName, &matNode);
		if(matNode) {
			maMaterialNode_t**	destNode;
			maGlobal.model->materialNodes.Get(destName, &destNode);
			if(destNode) {
				(*destNode)->child = *matNode;
			}
		}

		//Is this attribute a file node
		maFileNode_t** fileNode;
		maGlobal.model->fileNodes.Get(srcName, &fileNode);
		if(fileNode) {
			maMaterialNode_t**	destNode;
			maGlobal.model->materialNodes.Get(destName, &destNode);
			if(destNode) {
				(*destNode)->file = *fileNode;
			}
		}
	}

	if(srcType.Find("iog") != -1) {
		//Is this an attribute for one of our meshes
		for(int i = 0; i < maGlobal.model->objects.Num(); i++) {
			if(!strcmp(maGlobal.model->objects[i]->name, srcName)) {
				//maGlobal.model->objects[i]->materialRef = MA_AddMaterial(destName);
				strcpy(maGlobal.model->objects[i]->materialName, destName); 
				break;
			}
		}
	}

	return true;
}


void MA_BuildScale(idMat4& mat, float x, float y, float z) {
	mat.Identity();
	mat[0][0] = x;
	mat[1][1] = y;
	mat[2][2] = z;
}

void MA_BuildAxisRotation(idMat4& mat, float ang, int axis) {

	float sinAng = idMath::Sin(ang);
	float cosAng = idMath::Cos(ang);

	mat.Identity();
	switch(axis) {
	case 0: //x
		mat[1][1] = cosAng;
		mat[1][2] = sinAng;
		mat[2][1] = -sinAng;
		mat[2][2] = cosAng;
		break;
	case 1:	//y
		mat[0][0] = cosAng;
		mat[0][2] = -sinAng;
		mat[2][0] = sinAng;
		mat[2][2] = cosAng;
		break;
	case 2://z
		mat[0][0] = cosAng;
		mat[0][1] = sinAng;
		mat[1][0] = -sinAng;
		mat[1][1] = cosAng;
		break;
	}
}

void MA_ApplyTransformation(maModel_t *model) {
	
	for(int i = 0; i < model->objects.Num(); i++) {
		maMesh_t* mesh = &model->objects[i]->mesh;
		maTransform_t* transform = mesh->transform;
		
		

		while(transform) {

			idMat4 rotx, roty, rotz;
			idMat4 scale;

			rotx.Identity();
			roty.Identity();
			rotz.Identity();

			if(fabs(transform->rotate.x) > 0.0f) {
				MA_BuildAxisRotation(rotx, DEG2RAD(-transform->rotate.x), 0);
			}
			if(fabs(transform->rotate.y) > 0.0f) {
				MA_BuildAxisRotation(roty, DEG2RAD(transform->rotate.y), 1);
			}
			if(fabs(transform->rotate.z) > 0.0f) {
				MA_BuildAxisRotation(rotz, DEG2RAD(-transform->rotate.z), 2);
			}

			MA_BuildScale(scale, transform->scale.x, transform->scale.y, transform->scale.z);

			//Apply the transformation to each vert
			for(int j = 0; j < mesh->numVertexes; j++) {
				mesh->vertexes[j] = scale * mesh->vertexes[j];

				mesh->vertexes[j] = rotx * mesh->vertexes[j];
				mesh->vertexes[j] = rotz * mesh->vertexes[j];
				mesh->vertexes[j] = roty * mesh->vertexes[j];
				
				mesh->vertexes[j] = mesh->vertexes[j] + transform->translate;
			}
			
			transform = transform->parent;
		}
	}
}

/*
=================
MA_Parse
=================
*/
maModel_t *MA_Parse( const char *buffer, const char* filename, bool verbose ) {
	memset( &maGlobal, 0, sizeof( maGlobal ) );

	maGlobal.verbose = verbose;

	
	
	
	maGlobal.currentObject = NULL;

	// NOTE: using new operator because aseModel_t contains idList class objects
	maGlobal.model = new maModel_t;
	maGlobal.model->objects.Resize( 32, 32 );
	maGlobal.model->materials.Resize( 32, 32 );
	

	idParser parser;
	parser.SetFlags(LEXFL_NOSTRINGCONCAT);
	parser.LoadMemory(buffer, strlen(buffer), filename);

	idToken token;
	while(parser.ReadToken(&token)) {

		if(!token.Icmp("createNode")) {
			MA_ParseCreateNode(parser);
		} else if(!token.Icmp("connectAttr")) {
			MA_ParseConnectAttr(parser);
		}
	}

	//Resolve The Materials
	for(int i = 0; i < maGlobal.model->objects.Num(); i++) {
		maGlobal.model->objects[i]->materialRef = MA_AddMaterial(maGlobal.model->objects[i]->materialName);
	}

	

	//Apply Transformation
	MA_ApplyTransformation(maGlobal.model);

	return maGlobal.model;
}

/*
=================
MA_Load
=================
*/
maModel_t *MA_Load( const char *fileName ) {
	char *buf;
	ID_TIME_T timeStamp;
	maModel_t *ma;

	fileSystem->ReadFile( fileName, (void **)&buf, &timeStamp );
	if ( !buf ) {
		return NULL;
	}

	try {
		ma = MA_Parse( buf, fileName, false );
		ma->timeStamp = timeStamp;
	} catch( idException &e ) {
		common->Warning("%s", e.error);
		if(maGlobal.model) {
			MA_Free(maGlobal.model);
		}
		ma = NULL;
	}

	fileSystem->FreeFile( buf );

	return ma;
}

/*
=================
MA_Free
=================
*/
void MA_Free( maModel_t *ma ) {
	int					i;
	maObject_t			*obj;
	maMesh_t			*mesh;
	maMaterial_t		*material;

	if ( !ma ) {
		return;
	}
	for ( i = 0; i < ma->objects.Num(); i++ ) {
		obj = ma->objects[i];
		
		// free the base nesh
		mesh = &obj->mesh;
		
		if ( mesh->vertexes ) {
			Mem_Free( mesh->vertexes );
		}
		if ( mesh->vertTransforms ) {
			Mem_Free( mesh->vertTransforms );
		}
		if ( mesh->normals ) {
			Mem_Free( mesh->normals );
		}
		if ( mesh->tvertexes ) {
			Mem_Free( mesh->tvertexes );
		}
		if ( mesh->edges ) {
			Mem_Free( mesh->edges );
		}
		if ( mesh->colors ) {
			Mem_Free( mesh->colors );
		}
		if ( mesh->faces ) {
			Mem_Free( mesh->faces );
		}
		Mem_Free( obj );
	}
	ma->objects.Clear();

	for ( i = 0; i < ma->materials.Num(); i++ ) {
		material = ma->materials[i];
		Mem_Free( material );
	}
	ma->materials.Clear();

	maTransform_t** trans;
	for ( i = 0; i < ma->transforms.Num(); i++ ) {
		trans = ma->transforms.GetIndex(i);
		Mem_Free( *trans );
	}
	ma->transforms.Clear();


	maFileNode_t** fileNode;
	for ( i = 0; i < ma->fileNodes.Num(); i++ ) {
		fileNode = ma->fileNodes.GetIndex(i);
		Mem_Free( *fileNode );
	}
	ma->fileNodes.Clear();

	maMaterialNode_t** matNode;
	for ( i = 0; i < ma->materialNodes.Num(); i++ ) {
		matNode = ma->materialNodes.GetIndex(i);
		Mem_Free( *matNode );
	}
	ma->materialNodes.Clear();
	delete ma;
}