void* addXModel(zoneInfo_t* info, const char* name, char* data, size_t dataLen)
{
	if (data == NULL) return NULL;

	if(dataLen == 0)
	{
		XModel * model = (XModel*)data;
		short* boneNames = new short[model->numBones];

		for(int i=0; i<model->numBones; i++)
		{
			boneNames[i] = addScriptString(info, SL_ConvertToString(model->boneNames[i]));
		}

		model->boneNames = boneNames;

		for(int i=0; i<model->numSurfaces; i++)
		{
			// allow material overriding
			void* file;
			void* asset;

			if(int len = FS_ReadFile(va("zonebuilder/materials/%s.txt", model->materials[i]->name), &file) > 0)
			{
				asset = addMaterial(info, model->materials[i]->name, (char*)file, len);
				FS_FreeFile(file);
			}
			else
			{
				asset = addMaterial(info, model->materials[i]->name, (char*)model->materials[i], 0);
			}

			addAsset(info, ASSET_TYPE_MATERIAL, model->materials[i]->name, asset);
		}

		return data;
	}

	// copy stuff over
	XModel * base = (XModel*)DB_FindXAssetHeader(ASSET_TYPE_XMODEL, "viewmodel_mp5k");
	XModel * asset = new XModel;

	memcpy(asset, base, sizeof(XModel));
	asset->lods[0].surfaces = new XModelSurfaces;
	memcpy(asset->lods[0].surfaces, base->lods[0].surfaces, sizeof(XModelSurfaces));

	XModelSurfaces * surf = asset->lods[0].surfaces;
	surf->name = new char[strlen(name) + 6];
	sprintf((char*)surf->name, "%s_surf", name);

	BUFFER * buf = new BUFFER(data, dataLen);
	asset->name = new char[128];
	buf->readstr(asset->name, 128);
	buf->read(&asset->numBones, 4, 1);
	buf->read(&asset->numSubBones, 4, 1);
	buf->read(&asset->numSurfaces, 4, 1);
	surf->numSurfaces = asset->numSurfaces;
	asset->lods[0].numSurfs = surf->numSurfaces;

	asset->boneNames = new short[asset->numBones];

	for(int i=0; i<asset->numBones; i++)
	{
		char bone[64];
		buf->readstr(bone, 64);
		asset->boneNames[i] = addScriptString(info, bone);
	}

	// allocate stuff and load it
	if(asset->numBones - asset->numSubBones)
	{
		asset->parentList = new char[asset->numBones - asset->numSubBones];
		asset->tagAngles = new XModelAngle[asset->numBones - asset->numSubBones];
		asset->tagPositions = new XModelTagPos[asset->numBones - asset->numSubBones];

		buf->read(asset->parentList, sizeof(char), asset->numBones - asset->numSubBones);
		buf->read(asset->tagAngles, sizeof(XModelAngle), asset->numBones - asset->numSubBones);
		buf->read(asset->tagPositions, sizeof(XModelTagPos), asset->numBones - asset->numSubBones);
	}

	if(asset->numBones)
	{
		asset->partClassification = new char[asset->numBones];
		asset->animMatrix = new char[32 * asset->numBones];

		buf->read(asset->partClassification, sizeof(char), asset->numBones);
		buf->read(asset->animMatrix, 32, asset->numBones);
	}

	surf->surfaces = new XSurface[surf->numSurfaces];
	memset(surf->surfaces, 0, sizeof(XSurface) * surf->numSurfaces);
	
	for(int i=0; i<surf->numSurfaces; i++)
	{
		XSurface* s = &surf->surfaces[i];
		buf->read(&s->numVertices, 4, 1);
		buf->read(&s->numPrimitives, 4, 1);
		buf->read(&s->blendNum1, 4, 1);
		buf->read(&s->blendNum2, 4, 1);
		buf->read(&s->blendNum3, 4, 1);
		buf->read(&s->blendNum4, 4, 1);

		int blendCount = (s->blendNum4 * 7) + (s->blendNum3 * 5) + (s->blendNum2 * 3) + s->blendNum1;

		if(blendCount)
		{
			s->blendInfo = new char[blendCount * 2];
			buf->read(s->blendInfo, 2, blendCount);
		}
		else 
		{
			s->blendInfo = NULL;	
		}

		s->vertexBuffer = new GfxPackedVertex[s->numVertices];
		buf->read(s->vertexBuffer, 32, s->numVertices);

		int ct = 0;
		buf->read(&ct, 4, 1);

		if(ct)
		{
			buf->read(&s->numCT, 4, 1);
			s->ct = new XSurfaceCT[s->numCT];

			for(int j=0; j<s->numCT; j++)
			{
				XSurfaceCT* ct = &s->ct[j];
				buf->read(&ct->pad, 4, 1);
				buf->read(&ct->pad2, 4, 1);
				ct->entry = new XSurfaceCTEntry;
				buf->read(ct->entry, 24, 1);
				buf->read(&ct->entry->numNode, 4, 1);
				buf->read(&ct->entry->numLeaf, 4, 1);

				if(ct->entry->numNode)
				{
					ct->entry->node = new char[ct->entry->numNode * 16];
					buf->read(ct->entry->node, 16, ct->entry->numNode);
				}
				else
				{
					ct->entry->node = NULL;
				}

				if(ct->entry->numLeaf)
				{
					ct->entry->leaf = new short[ct->entry->numLeaf];
					buf->read(ct->entry->leaf, 2, ct->entry->numLeaf);
				}
				else
				{
					ct->entry->node = NULL;
				}
			}
		}
		else
		{
			s->ct = NULL;
			s->numCT = 0;
		}

		s->indexBuffer = new Face[s->numPrimitives];
		buf->read(s->indexBuffer, sizeof(Face), s->numPrimitives);
	}

	asset->materials = new Material*[asset->numSurfaces];

	// read the material stuff and load a material if we need it
	for(int i=0; i<asset->numSurfaces; i++)
	{
		char matName[64] = { 0 };
		char techName[64] = { 0 };
		char matFileName[78] = { 0 };

		buf->readstr(matName, 50);
		buf->readstr(techName, 64);

		char* filename = matName;

		// asset is already in db... dont re-add it
		if (containsAsset(info, ASSET_TYPE_MATERIAL, matName) > 0)
		{
			asset->materials[i] = (Material*)getAsset(info, ASSET_TYPE_MATERIAL, matName);
			continue;
		}

		if(!strncmp("mc/", matName, 3)) filename = matName + 3;

		_snprintf(matFileName, sizeof(matFileName), "materials/%s.txt", filename);

		void* matBuf;
		int len = FS_ReadFile(matFileName, &matBuf);

		if(len > 0)
		{
			asset->materials[i] = (Material*)addMaterial(info, matName, (char*)matBuf, len);
			FS_FreeFile(matBuf);
		}
		else
		{
			asset->materials[i] = (Material*)DB_FindXAssetHeader(ASSET_TYPE_MATERIAL, matName);
			addMaterial(info, matName, (char*)asset->materials[i], 0);
		}

		addAsset(info, ASSET_TYPE_MATERIAL, matName, asset->materials[i]);		
	}

	int test = 0;
	buf->read(&test, 4, 1);

	if(test) Com_Error(false, "Cause NTA said so!");

	buf->read(&test, 4, 1);

	if(!test) Com_Error(false, "Cause NTA said so!");

	asset->unknowns = new char[asset->numBones * 28];
	buf->read(asset->unknowns, 28, asset->numBones);

	return asset;
}