DOOM-3-BFG

Model_ma.cpp (28584B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
 
 ===========================================================================
 */
 
 #pragma hdrstop
 #include "../idlib/precompiled.h"
 
 #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()) );
 	}
 
 
 	//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 ), TAG_MODEL );
 	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, TAG_MODEL );
 	}
 
 	//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, TAG_MODEL );
 		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, TAG_MODEL );
 	}
 
 	//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, TAG_MODEL );
 	}
 
 	//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, TAG_MODEL );
 	}
 
 	//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()));
 			}
 			//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(); uvstIndex;
 			int count = parser.ParseInt();
 			if(count != 3) {
 				throw idException(va("Maya Loader '%s': Invalid texture coordinates.", parser.GetFileName()));
 			}
 			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()));
 			}
 			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()));
 			}
 			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, TAG_MODEL );
 	}
 
 	//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, TAG_MODEL );
 	}
 
 	//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 ), TAG_MODEL );
 	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 ), TAG_MODEL );
 				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 ), TAG_MODEL );
 	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 ), TAG_MODEL );
 			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()));
 	}
 	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()));
 	}
 	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 (TAG_MODEL) 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.GetError());
 		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;
 }