using UnityEngine;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using System;

namespace uSrcTools
{

	[System.Serializable]
	public class SourceStudioModel// : MonoBehaviour
	{
		public string curModelName;

        public studiohdr_t mdlHeader;
		public vvdheader vvdHeader;
		public vtxHeader vtxHeader;

		public int lodLevel=0;
		int skin;
		int numSkinRefs;
		public int submeshCount=0;
		public Material tempMat;
		
		public int vertCount;
		public Vector3[] vertArray;
		public Vector3[] Normals;
		public Vector2[] UV;
		public BoneWeight[] boneWeights;
		public int[] indexArray;
		public Dictionary<int,int[]> trisArrays;

		public studiobone_t[] mdlBones;

		public studiobodypart[] mdlBodyParts;

		public vtxBodypartHeader[] vtxBodyParts;

		public studiotexture_t[] mdlTextures;
		public string[] mdlTexturePaths;
		public short[] mdlSkinFamilies;

		public Transform[] Bones;
		Mesh modelMesh;
		bool used;
		public bool loaded=false;
		public bool drawArmature=false;
		Material[] TempMats;

		public SourceStudioModel Load(string path, Func<string, Stream> openFileCallback)
		{

			curModelName = path;
            //studiobodypart[] mdlBodyParts;
            if (!ParseMdl (path, openFileCallback))
			{
				return null;
			}
			
			LoadSkin (0);
			
			//public int vertCount;
			//Vector3[] vertArray;
			//Vector3[] Normals;
			//Vector2[] UV;
			//int[] indexArray;
			
			
			ParseVvd (path, openFileCallback);
			
			ParseVtx (path, openFileCallback);

			loaded = true;

			return this;
		}
/*
		public void GetInstance(GameObject go, bool skinned)
		{
			BuildMeshObject (curModelName, go,skinned);
		}

		public void GetInstance(GameObject go)
		{
			BuildMeshObject (curModelName, go,false);
		}*/

		public void GetInstance(GameObject go, bool skinned,int bp)
		{
			BuildMeshObject (curModelName, go, skinned,bp);
		}

		public void OnDrawGizmos()
		{
			/*for (int i=0; i<vertArray.Length; i++) 
			{
				Gizmos.DrawCube(vertArray[i],Vector3.one*0.2f);
			}*/
			if (loaded & used & drawArmature) 
			{
				for(int i=0;i<Bones.Length;i++)
				{
					Gizmos.color=Color.white;
					Gizmos.DrawWireCube(Bones[i].position,Vector3.one*0.02f);
					if(mdlBones[i].parent!=-1)
					{
						Gizmos.color=Color.yellow;
						Gizmos.DrawLine(Bones[i].position,Bones[mdlBones[i].parent].position);
					}
				}
			}
		}

		void BuildMeshObjectOLD(string modelName, GameObject go, bool skinned)
		{
			if (!loaded) 
			{
				Debug.LogWarning("Can't get Instance of model "+modelName+" because it's not loaded");
				return;
			}

			if(used)
			{
				Bones = new Transform[mdlHeader.bonesnum];
				for (int i=0; i<mdlHeader.bonesnum; i++) 
				{
					GameObject bone = new GameObject(mdlBones[i].pszName);
					if(mdlBones[i].parent>=0)
					{
						bone.transform.SetParent(Bones[mdlBones[i].parent]);
					}
					else
					{
						bone.transform.SetParent(go.transform);
					}
					Vector3 temp=Vector3.zero;
					//if(i==0)
					temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.z,mdlBones[i].pos.y);
					//else
					//	temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.y,-mdlBones[i].pos.z);
					
					bone.transform.localPosition=temp * SourceImportConfig.WorldScale;
					Vector3 rot=new Vector3(-mdlBones[i].rot.x*Mathf.Rad2Deg,-mdlBones[i].rot.z*Mathf.Rad2Deg,-mdlBones[i].rot.y*Mathf.Rad2Deg);
					bone.transform.localEulerAngles=rot;
					Bones[i]=bone.transform;
				}

				if (skinned) 
				{
					go.AddComponent<MeshFilter> ().mesh = modelMesh;
					SkinnedMeshRenderer smr = go.AddComponent<SkinnedMeshRenderer> ();
					smr.material = tempMat;
					smr.sharedMesh = modelMesh;
					smr.bones=Bones;
					smr.rootBone=Bones[0];
					smr.updateWhenOffscreen=true;

				} 
				else 
				{
					go.AddComponent<MeshFilter> ().mesh = modelMesh;
					go.AddComponent<MeshRenderer> ().material = tempMat;
				}
				return;
			}

			//==========================================================
			Bones = new Transform[mdlHeader.bonesnum];
			for (int i=0; i<mdlHeader.bonesnum; i++) 
			{
				GameObject bone = new GameObject(mdlBones[i].pszName);
				if(mdlBones[i].parent>=0)
				{
					bone.transform.SetParent(Bones[mdlBones[i].parent]);
				}
				else
				{
					bone.transform.SetParent(go.transform);
				}
				Vector3 temp=Vector3.zero;
				//if(i==0)
					temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.z,mdlBones[i].pos.y);
				//else
				//	temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.y,-mdlBones[i].pos.z);

				bone.transform.localPosition=temp* SourceImportConfig.WorldScale;
				Vector3 rot=new Vector3(-mdlBones[i].rot.x*Mathf.Rad2Deg,-mdlBones[i].rot.z*Mathf.Rad2Deg,-mdlBones[i].rot.y*Mathf.Rad2Deg);
				bone.transform.localEulerAngles=rot;
				Bones[i]=bone.transform;
			}
			//============================================================================================

			string materialName="";

            /*if(mdlTexturePaths.Length==1)
			{
				materialName += mdlTexturePaths[0];
				materialName += mdlTextures[mdlBodyParts[0].models[0].meshes[0].material].textureName;
			}
			else
			{
				string path = ResourceManager.GetPath ("materials/"+mdlTexturePaths[0]
				       +mdlTextures[mdlBodyParts[0].models[0].meshes[0].material].textureName+".vmt");
				
				if(path==null)
				{
					Debug.Log ("Try second path");
					path = ResourceManager.GetPath ("materials/"+mdlTexturePaths[1]
					   +mdlTextures[mdlBodyParts[0].models[0].meshes[0].material].textureName+".vmt");
					if(path!=null)
					{
						materialName=mdlTexturePaths[1]
						+mdlTextures[mdlBodyParts[0].models[0].meshes[0].material].textureName;
					}
				}
			}

			if (uSrcSettings.Inst.textures)
				tempMat = ResourceManager.Inst.GetMaterial (materialName);
			else
				tempMat = Test.Inst.testMaterial;*/

			//TODO: restore mat system
            var matPath = AssetDatabase.FindAssets("DefaultBspMaterial");
            var assetPath = AssetDatabase.GUIDToAssetPath(matPath[0]);
            tempMat = AssetDatabase.LoadAssetAtPath<Material>(assetPath);

            //============================================================================================

            //GameObject testMesh = new GameObject (curModelName);
            //testMesh.transform.position = position;
            modelMesh = new Mesh ();
			modelMesh.name = curModelName;

			modelMesh.vertices = vertArray;
			modelMesh.normals = Normals;
			modelMesh.uv = UV;
			modelMesh.boneWeights = boneWeights;
			//======================================================
			Matrix4x4[] bindPoses = new Matrix4x4[Bones.Length];
			for (int i = 0; i < bindPoses.Length; i++)
			{
				//Bones[i].localPosition = Vector3.zero;
				bindPoses[i] = Bones[i].worldToLocalMatrix * go.transform.localToWorldMatrix;
			}
			modelMesh.bindposes = bindPoses;

			//====================================================================
			//Debug.Log (indexArray.Length+" indices");

			modelMesh.triangles = indexArray;
			/*
			int numMeshes = vtxBodyParts [0].models [0].lods [lodLevel].numMeshes;
			modelMesh.subMeshCount = numMeshes;
			int indexCount = 0;
			int indexOffset = 0;
			for(int i=0; i<numMeshes; i++)
			{
				indexOffset=indexCount;//vtxBodyParts [0].models [0].lods [lodLevel].meshes[i].stripGroups[0].strips[0].indexOffset;
				indexCount = vtxBodyParts [0].models [0].lods [lodLevel].meshes[i].stripGroups[0].strips[0].numIndices;
				int[] tempIndex = new int[indexCount];
				System.Buffer.BlockCopy(indexArray,indexOffset*4,tempIndex,0,indexCount*4);
				Debug.Log("Mesh "+i+" index count is "+indexCount+" index offset "+indexOffset);
				modelMesh.SetTriangles(tempIndex, i);
			}
			*/
			//modelMesh.subMeshCount = 1;
			/*int indexCount = indexArray.Length;

			int[] tempIndex = new int[indexCount];
			System.Buffer.BlockCopy(indexArray,0,tempIndex,0,indexCount*4);
			//modelMesh.SetTriangles(tempIndex, 0);
			modelMesh.triangles = tempIndex;*/
			//===================================================================

			modelMesh.RecalculateBounds ();
			//modelMesh.Optimize ();

			if (skinned) 
			{
				go.AddComponent<MeshFilter> ().mesh = modelMesh;
				SkinnedMeshRenderer smr = go.AddComponent<SkinnedMeshRenderer> ();
				smr.material = tempMat;
				smr.sharedMesh = modelMesh;
				smr.bones=Bones;
				smr.rootBone=Bones[0];
				smr.updateWhenOffscreen=true;
			} else 
			{
				go.AddComponent<MeshFilter> ().mesh = modelMesh;
				go.AddComponent<MeshRenderer> ().material = tempMat;
			}

			for (int i=0; i<mdlHeader.bonesnum; i++) 
			{
				Vector3 temp=Vector3.zero;
				//if(i==0)
					temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.z,mdlBones[i].pos.y);
				//else
				//	temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.y,-mdlBones[i].pos.z);
				Bones[i].transform.localPosition=temp*SourceImportConfig.WorldScale;
				Vector3 rot=new Vector3(-mdlBones[i].rot.x*Mathf.Rad2Deg,-mdlBones[i].rot.z*Mathf.Rad2Deg,-mdlBones[i].rot.y*Mathf.Rad2Deg);
				Bones[i].transform.localEulerAngles=rot;
			}

			//tempMat = new Material (Shader.Find("Diffuse"));

			/*for (int i=0; i<mdlBodyParts.Length; i++) 
			{
				GameObject bodyPartObj=new GameObject(mdlBodyParts[i].name);
				bodyPartObj.transform.SetParent(go.transform);

				for (int m=0; m<mdlBodyParts[i].models.Length; m++) 
				{
					GameObject modelObj=new GameObject(mdlBodyParts[i].models[m].name);
					modelObj.transform.SetParent(bodyPartObj.transform);

					for (int meshId=0; meshId<mdlBodyParts[i].models[m].meshnum; meshId++) 
					{
						GameObject meshObj=new GameObject("Mesh "+meshId);
						meshObj.transform.SetParent(modelObj.transform);

						//Mesh mesh = new Mesh ();
						//mesh.name = mdlBodyParts[i].models[m].name+" Mesh "+meshId;

						//mesh.vertices = vertArray;
						//mesh.normals = Normals;
						//mesh.uv = UV;
						//Debug.Log (indexArray.Length+" indices");
						//mesh.triangles = indexArray;
						
						//meshObj.AddComponent<MeshFilter> ().mesh = mesh;
						//meshObj.AddComponent<MeshRenderer> ().material = tempMat;
					}
				}
			}*/

			used = true;
		}

		void BuildMeshObject(string modelName, GameObject go, bool skinned,int bp)
		{
			if (!loaded) 
			{
				Debug.LogWarning("Can't get Instance of model "+modelName+" because it's not loaded");
				return;
			}
			
			if(skinned)
			{
				Bones = new Transform[mdlHeader.bonesnum];
				for (int i=0; i<mdlHeader.bonesnum; i++) 
				{
					GameObject bone = new GameObject(mdlBones[i].pszName);
					if(mdlBones[i].parent>=0)
					{
						bone.transform.SetParent(Bones[mdlBones[i].parent]);
					}
					else
					{
						bone.transform.SetParent(go.transform);
					}
					Vector3 temp=Vector3.zero;
					//if(i==0)
						temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.z,mdlBones[i].pos.y);
					//else
					//	temp=new Vector3(mdlBones[i].pos.x,mdlBones[i].pos.y,-mdlBones[i].pos.z);

					bone.transform.localPosition=temp*SourceImportConfig.WorldScale;
					Vector3 rot=new Vector3(-mdlBones[i].rot.x*Mathf.Rad2Deg,-mdlBones[i].rot.z*Mathf.Rad2Deg,-mdlBones[i].rot.y*Mathf.Rad2Deg);
					bone.transform.localEulerAngles=rot;
					Bones[i]=bone.transform;
				}
			}
			
			if(!used)
			{
				modelMesh = new Mesh ();
				modelMesh.name = curModelName;
				
				modelMesh.vertices = vertArray;
				if(modelMesh.vertices.Length==0)
					Debug.LogWarning ("Error with model "+modelName);
								
				modelMesh.normals = Normals;
				modelMesh.uv = UV;
				modelMesh.boneWeights = boneWeights;

				modelMesh.subMeshCount = submeshCount;
				//Debug.Log ("submeshCount " + submeshCount);
				//Debug.Log ("indexCount "+indexArray.Length);
				//Debug.Log ("Bodypart count "+vtxBodyParts.Length);
				int curmeshId=0;
				int curIndexOffset = 0;
				
				
				if(TempMats==null)
					TempMats = new Material[submeshCount];

				//for(int bpId=0; bpId<vtxBodyParts.Length; bpId++)
				//{
				int bpId=0;

				vtxBodypartHeader vtxBodyPart = vtxBodyParts[bpId];
				studiobodypart mdlBodyPart = mdlBodyParts[bpId];
				for(int modelId=0; modelId<vtxBodyPart.models.Length; modelId++)
				{
					vtxModelHeader vtxModel = vtxBodyPart.models[modelId];
					studiomodel mdlModel=mdlBodyPart.models[modelId];

					vtxModelLODheader _lod = vtxModel.lods[lodLevel];

					for(int meshId=0; meshId<_lod.numMeshes; meshId++)
					{
						vtxMeshHeader vtxMesh=_lod.meshes[meshId];
						studiomesh mdlMesh=mdlModel.meshes[meshId];

						int materialId=mdlMesh.material+(numSkinRefs*skin);
						string material=mdlTextures[mdlSkinFamilies[materialId]].textureName;
						//Debug.Log ("Mesh "+curmeshId+" material is "+material);

						if(TempMats[curmeshId]==null)
						{
                            /*string materialName=ResourceManager.FindModelMaterialFile(material,mdlTexturePaths);

							if(materialName!=null)
								TempMats[curmeshId] = ResourceManager.Inst.GetMaterial(materialName);
							else
								TempMats[curmeshId] = ResourceManager.Inst.GetMaterial(material);*/

							//TPDO: restore mat find
                            var matPath = AssetDatabase.FindAssets("DefaultBspMaterial");
                            var assetPath = AssetDatabase.GUIDToAssetPath(matPath[0]);
                            tempMat = AssetDatabase.LoadAssetAtPath<Material>(assetPath);
							TempMats[curmeshId] = tempMat;
                        }
						
						for(int stripGroupId=0; stripGroupId<vtxMesh.numStripGroups; stripGroupId++)
						{
							vtxStripGroupHeader stripGroup=vtxMesh.stripGroups[stripGroupId];
							
							//for(int stripId=0; stripId<stripGroup.numStrips;stripId++)
							//{
			//====================
			//vtxStripGroupHeader stripGroup=vtxBodyParts[0].models[0].lods[lodLevel].meshes[0].stripGroups[0];
			//vtxStripHeader strip=stripGroup.strips[0];
			//====================

								//vtxStripHeader strip=stripGroup.strips[stripId];

								//int indexOffset=stripGroup.indexOffs+strip.indexOffset;
								//int numIndices=strip.numIndices;
								int indexOffset=curIndexOffset;
								int numIndices=stripGroup.numIndices*4;

								//Debug.Log("Mesh "+curmeshId+" index count is "+numIndices/4+" index offset "+indexOffset/4);

								int[] tempIndex = new int[stripGroup.numIndices];
								System.Buffer.BlockCopy(indexArray,indexOffset,tempIndex,0,numIndices);
								modelMesh.SetTriangles(tempIndex, curmeshId);
						if(modelMesh.GetTriangles(curmeshId).Length==0)
							Debug.LogWarning ("Error with model "+modelName+": setting tris for "+curmeshId+" submesh");
								
								curmeshId++;
							curIndexOffset+=stripGroup.numIndices*4;
							//}
						}
					}//mesh
				}//model
			//}//bp
			}//!used
			
			//Vector3 rot=new Vector3(-mdlBones[i].rot.x*Mathf.Rad2Deg,-mdlBones[i].rot.z*Mathf.Rad2Deg,-mdlBones[i].rot.y*Mathf.Rad2Deg);
			Vector3 rootrot = new Vector3(0,-mdlBones[0].rot.x*Mathf.Rad2Deg,0);

			go.transform.localEulerAngles+=rootrot;

			var mf = go.GetComponent<MeshFilter>();
			if(mf == null) {
                mf = go.AddComponent<MeshFilter>();
            }

            mf.sharedMesh = modelMesh;


			MeshRenderer mr = go.GetComponent<MeshRenderer> ();
			if(mr == null) {
                mr = go.AddComponent<MeshRenderer>();

            }
			mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided; //Making model shadows two-sided for better quality.
			
			modelMesh.RecalculateBounds ();
			mr.materials = TempMats;
			mr.lightmapIndex = 255;
			
			used = true;
		}


		void LoadSkin(int skinId)
		{
			skin = skinId;

			int skinTableOffset=numSkinRefs * skinId;
			for(int i=0; i<numSkinRefs; i++)
			{
				int texId = mdlSkinFamilies[skinTableOffset+i];
				string textureName = "";
				if(texId<mdlTexturePaths.Length)
					textureName += mdlTexturePaths[texId];
				else
					textureName += mdlTexturePaths[mdlTexturePaths.Length-1];
				textureName += mdlTextures [texId].textureName;
				//LoadMaterial(textureName)
				//Debug.Log ("Need to load material "+textureName);
			}
		}

		public bool ParseMdl(string name, Func<string, Stream> openFileCallback)
		{
			BinaryReader BR = new BinaryReader (openFileCallback(name));

			//studiohdr_t Header = ReadHeader (BR);
			mdlHeader = ReadHeader (BR);

			if (new string(mdlHeader.id) != "IDST") 
			{
				Debug.LogWarning ("Header id is not IDST");
				BR.BaseStream.Close ();
				return false;
			}


			mdlBones = ReadStudioBones (BR,mdlHeader.boneoffs,mdlHeader.bonesnum);

			mdlTextures = ReadStudioTextures(BR,mdlHeader.textureoffs,mdlHeader.texturenum);

			mdlTexturePaths = ReadTexturePaths (BR, mdlHeader.texturediroffs, mdlHeader.texturedirnum);

			numSkinRefs = mdlHeader.skinrefnum;
			mdlSkinFamilies = ReadSkinFamilies (BR,mdlHeader.skinfamilyoffs, mdlHeader.skinfamilynum,mdlHeader.skinrefnum);

			mdlBodyParts = ReadMdlBodyParts (BR, mdlHeader.bodypartoffs, mdlHeader.bodypartnum);

			//setRootLOD (mdlHeader, lodLevel);

			BR.BaseStream.Dispose ();
			
			return true;
		}

		void setRootLOD(studiohdr_t hdr, int lod)
		{
			if (hdr.numAllowedRootLods > 0 && lod >= hdr.numAllowedRootLods) 
			{
				lod=hdr.numAllowedRootLods-1;
			}

			int vertexOffset=0;

			for (int bpId=0; bpId<mdlBodyParts.Length; bpId++) 
			{
				studiobodypart bodypart = mdlBodyParts [bpId];
				for (int modelId=0; modelId<bodypart.models.Length; modelId++) 
				{
					studiomodel model = bodypart.models [modelId];

					int totalMeshVertices = 0;
					for (int meshId=0; meshId<model.meshnum; meshId++) 
					{
						studiomesh mesh = model.meshes [meshId];

						mesh.vertexnum=mesh.vertexdata.numLODVertexes[lod];
						mesh.vertexoffs=totalMeshVertices;
						totalMeshVertices+=mesh.vertexnum;
					}

					model.verticesnum=totalMeshVertices;
					model.verticesoffs=vertexOffset;
					vertexOffset+=totalMeshVertices;
				}
			}
			Debug.Log ("Vertixes count "+vertexOffset);
			lodLevel = lod;
		}

		studiohdr_t ReadHeader(BinaryReader BR)
		{
			studiohdr_t hdr = new studiohdr_t ();

			hdr.id = BR.ReadChars(4);
			hdr.version = BR.ReadInt32 ();
			hdr.checksum = BR.ReadInt32 ();
			hdr.Name = new string(BR.ReadChars (64));
			hdr.Name = hdr.Name.Remove (hdr.Name.IndexOf ('\0'));
	//		Debug.Log("Model "+hdr.Name+" version is "+hdr.version);
			hdr.length = BR.ReadInt32 ();

			//header01

			hdr.eyeposition = new Vector3(BR.ReadSingle (), BR.ReadSingle (), BR.ReadSingle ());
			hdr.illumposition = new Vector3(BR.ReadSingle (), BR.ReadSingle (), BR.ReadSingle ());

			hdr.hullmin = new Vector3(BR.ReadSingle (), BR.ReadSingle (), BR.ReadSingle ());
			hdr.hullmax = new Vector3(BR.ReadSingle (), BR.ReadSingle (), BR.ReadSingle ());

			hdr.view_bbmin = new Vector3(BR.ReadSingle (), BR.ReadSingle (), BR.ReadSingle ());
			hdr.view_bbmax = new Vector3(BR.ReadSingle (), BR.ReadSingle (), BR.ReadSingle ());

			hdr.flags = BR.ReadInt32 ();

			hdr.bonesnum = BR.ReadInt32 ();
			hdr.boneoffs = BR.ReadInt32 ();

			hdr.bonecontrollernum = BR.ReadInt32 ();
			hdr.bonecontrolleroffs = BR.ReadInt32 ();

			hdr.hitboxnum = BR.ReadInt32 ();
			hdr.hitboxoffs = BR.ReadInt32 ();

			hdr.localanimnum = BR.ReadInt32 ();
			hdr.localanimoffs = BR.ReadInt32 ();

			hdr.localseqnum = BR.ReadInt32 ();
			hdr.localseqoffs = BR.ReadInt32 ();

			hdr.activitylistversion = BR.ReadInt32 ();
			hdr.eventsindexed = BR.ReadInt32 ();

			hdr.texturenum = BR.ReadInt32 ();
			hdr.textureoffs = BR.ReadInt32 ();

			hdr.texturedirnum = BR.ReadInt32 ();
			hdr.texturediroffs = BR.ReadInt32 ();

			hdr.skinrefnum = BR.ReadInt32 ();
			hdr.skinfamilynum = BR.ReadInt32 ();
			hdr.skinfamilyoffs = BR.ReadInt32 ();

			hdr.bodypartnum = BR.ReadInt32 ();
			hdr.bodypartoffs = BR.ReadInt32 ();

			hdr.attachmentnum = BR.ReadInt32 ();
			hdr.attachmentoffs = BR.ReadInt32 ();

			hdr.localnodenum = BR.ReadInt32 ();
			hdr.localnodeoffs = BR.ReadInt32 ();

			hdr.localnodenameoffs = BR.ReadInt32 ();

			hdr.flexdescnum = BR.ReadInt32 ();
			hdr.flexdescoffs = BR.ReadInt32 ();

			hdr.flexcontrollernum = BR.ReadInt32 ();
			hdr.flexcontrolleroffs = BR.ReadInt32 ();

			hdr.flexrulesnum = BR.ReadInt32 ();
			hdr.flexrulesoffs = BR.ReadInt32 ();

			hdr.ikchainnum = BR.ReadInt32 ();
			hdr.ikchainoffs = BR.ReadInt32 ();

			hdr.mouthsnum = BR.ReadInt32 ();
			hdr.mouthsoffs = BR.ReadInt32 ();

			hdr.localposeparamnum = BR.ReadInt32 ();
			hdr.localposeparamoffs = BR.ReadInt32 ();

			hdr.surfacepropoffs = BR.ReadInt32 ();

			hdr.keyvalueoffs = BR.ReadInt32 ();
			hdr.keyvaluenum = BR.ReadInt32 ();

			hdr.iklocknum = BR.ReadInt32 ();
			hdr.iklockoffs = BR.ReadInt32 ();

			hdr.mass = BR.ReadSingle ();

			hdr.contents = BR.ReadInt32 ();

			hdr.includemodelnum = BR.ReadInt32 ();
			hdr.includemodeloffs = BR.ReadInt32 ();

			hdr.virtualModel = BR.ReadInt32 ();

			hdr.animblocksnameoffs = BR.ReadInt32 ();
			hdr.animblocksnum = BR.ReadInt32 ();
			hdr.animblocksoffs = BR.ReadInt32 ();
			hdr.animblockModel = BR.ReadInt32 ();

			hdr.bonetablenameoffs = BR.ReadInt32 ();

			hdr.vertex_base = BR.ReadInt32 ();
			hdr.offset_base = BR.ReadInt32 ();

			hdr.directionaldotproduct = BR.ReadByte ();

			hdr.rootLod = BR.ReadByte ();
			hdr.numAllowedRootLods = BR.ReadByte ();

			BR.BaseStream.Seek (5, SeekOrigin.Current);

			hdr.flexcontrolleruinum = BR.ReadInt32 ();
			hdr.flexcontrolleruioffs = BR.ReadInt32 ();

			BR.BaseStream.Seek (8,SeekOrigin.Current);

			hdr.studiohdr2offs = BR.ReadInt32 ();

			BR.BaseStream.Seek (4,SeekOrigin.Current);

			return hdr;
		}

		studiobone_t[] ReadStudioBones(BinaryReader br, int offs, int num)
		{
			studiobone_t[] bones = new studiobone_t[num];
			
			br.BaseStream.Seek (offs, SeekOrigin.Begin);
			for (int i=0; i<num; i++) 
			{
				//BR.BaseStream.Seek (offs+(i*216), SeekOrigin.Begin);
				bones[i] = new studiobone_t();
				bones[i].sznameindex = br.ReadInt32();
				bones[i].parent = br.ReadInt32();
				bones[i].bonecontroller =new int[]{ br.ReadInt32(),br.ReadInt32(),
					br.ReadInt32(),br.ReadInt32(),br.ReadInt32(),br.ReadInt32() };
				bones[i].pos = ConvertUtils.ReadVector3( br);
				bones[i].quat = ConvertUtils.ReadQuat( br);
				bones[i].rot = ConvertUtils.ReadVector3( br);
				bones[i].posscale = ConvertUtils.ReadVector3( br);
				bones[i].rotscale = ConvertUtils.ReadVector3( br);

				bones[i].poseToBone = new float[]{
					br.ReadSingle(),br.ReadSingle(),br.ReadSingle(),
					br.ReadSingle(),br.ReadSingle(),br.ReadSingle(),
					br.ReadSingle(),br.ReadSingle(),br.ReadSingle(),
					br.ReadSingle(),br.ReadSingle(),br.ReadSingle()};

				bones[i].qAlignment = ConvertUtils.ReadQuat( br);
				bones[i].flags = br.ReadInt32();
				bones[i].proctype = br.ReadInt32();
				bones[i].procindex = br.ReadInt32();
				bones[i].physicsbone = br.ReadInt32();
				bones[i].surfacepropidx = br.ReadInt32();
				bones[i].contents = br.ReadInt32();
				br.BaseStream.Seek(32,SeekOrigin.Current);
			}

			for (int i=0; i<num; i++) 
			{
				bones[i].pszName = ConvertUtils.ReadNullTerminatedString(br,offs+(i*216)+bones[i].sznameindex);
			}
			
			return bones;
		}

		studiobodypart[] ReadMdlBodyParts(BinaryReader br, int offs, int num)
		{
			studiobodypart[] bp = new studiobodypart[num];

			br.BaseStream.Seek (offs, SeekOrigin.Begin);
	//		Debug.Log ("numBodyParts: "+num);
			for (int i=0; i<num; i++) 
			{
				br.BaseStream.Seek (offs+(i*16), SeekOrigin.Begin);
				bp[i] = new studiobodypart(br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 ());
				//bp[i].name = ConvertUtils.ReadNullTerminatedString(BR,offs+(i*16)+bp[i].nameindex);
				bp[i].models = ReadStudioModels(br, offs+(i*16), bp[i]);
			}

			for (int i=0; i<num; i++) 
			{
				bp[i].name = ConvertUtils.ReadNullTerminatedString(br,offs+(i*16)+bp[i].nameindex);
			}

			return bp;
		}

		studiomodel[] ReadStudioModels(BinaryReader BR, int offset, studiobodypart bp)
		{
			BR.BaseStream.Seek (bp.modelindex+offset, SeekOrigin.Begin);
			studiomodel[] temp = new studiomodel[bp.nummodels];
			for (int i=0; i<bp.nummodels; i++) 
			{
				BR.BaseStream.Seek (bp.modelindex + offset + (i*148), SeekOrigin.Begin);
				string tempName=new string (BR.ReadChars (64));
				if(tempName.Contains ('\0'))
					tempName = tempName.Remove (tempName.IndexOf ('\0'));
				temp[i] = new studiomodel (tempName, BR.ReadInt32 (), BR.ReadSingle (), BR.ReadInt32 (),
		              				   BR.ReadInt32 (), BR.ReadInt32 (), BR.ReadInt32 (), BR.ReadInt32 (),
				                           BR.ReadInt32 (), BR.ReadInt32 (), BR.ReadInt32 (), BR.ReadInt32 (),new mstudio_modelvertexdata_t(BR.ReadInt32(),BR.ReadInt32()));
				BR.BaseStream.Seek (32, SeekOrigin.Current);
				//length 148

				temp[i].meshes = ReadStudioMeshes(BR, bp.modelindex + offset + (i*148), temp[i]);

			}
			return temp;
		}

		studiomesh[] ReadStudioMeshes(BinaryReader BR, int offset, studiomodel model)
		{
			studiomesh[] temp = new studiomesh[model.meshnum];

			BR.BaseStream.Seek (model.meshoffs + offset, SeekOrigin.Begin);
			for (int i=0; i<model.meshnum; i++) 
			{
				//BR.BaseStream.Seek (model.meshoffs + offset + (i*116), SeekOrigin.Begin);
				temp[i] = new studiomesh(BR.ReadInt32(), BR.ReadInt32(), BR.ReadInt32(), 
						                       BR.ReadInt32(), BR.ReadInt32(), BR.ReadInt32(), 
						                       BR.ReadInt32(), BR.ReadInt32(), BR.ReadInt32(), 
				                               new Vector3(BR.ReadSingle(),BR.ReadSingle(),BR.ReadSingle()),
				                               new studio_meshvertexdata(BR.ReadInt32(),
											   new int[]{BR.ReadInt32(),BR.ReadInt32(),BR.ReadInt32(),BR.ReadInt32(),
											   			 BR.ReadInt32(),BR.ReadInt32(),BR.ReadInt32(),BR.ReadInt32()})
				                      );
				BR.BaseStream.Seek (32, SeekOrigin.Current);
			}
			return temp;
		}

		studiotexture_t[] ReadStudioTextures(BinaryReader br, int offset, int count)
		{
			br.BaseStream.Seek (offset, SeekOrigin.Begin);

			studiotexture_t[] st = new studiotexture_t[count];

			for (int i=0; i<count; i++) 
			{
				st[i] = new studiotexture_t();
				st[i].name_offset = br.ReadInt32();
				st[i].flags=br.ReadInt32();
				st[i].used=br.ReadInt32();
				st[i].unused=br.ReadInt32();
				st[i].material=br.ReadInt32();
				st[i].client_material=br.ReadInt32();
				br.BaseStream.Seek(40,SeekOrigin.Current);
			}

			for (int i=0; i<count; i++) 
			{
				br.BaseStream.Seek(offset + st[i].name_offset + (i*64),SeekOrigin.Begin);
				st[i].textureName = ConvertUtils.ReadNullTerminatedString(br);
				//Debug.Log ("Texture "+i+" name is "+st[i].textureName);
			}

			return st;
		}

		string[] ReadTexturePaths(BinaryReader br, int offs, int count)
		{
			int[] texturePathOffs=new int[count];
			string[] texturePaths=new string[count];
			br.BaseStream.Seek (offs, SeekOrigin.Begin);
			for (int i=0; i<count; i++) 
			{
				texturePathOffs[i]=br.ReadInt32();
			}

			for (int i=0; i<count; i++) 
			{
				string tempStr=ConvertUtils.ReadNullTerminatedString(br,texturePathOffs[i]);
				tempStr=tempStr.Replace ("\\","/");
				texturePaths[i]=tempStr;
				//Debug.Log ("texturePath "+i+" is "+texturePaths[i]);
			}
			return texturePaths;
		}

		short[] ReadSkinFamilies(BinaryReader br,int offs,int count, int refCount)
		{
			short[] skinFams = new short[count*refCount];

			br.BaseStream.Seek (offs, SeekOrigin.Begin);
			for (int i=0; i<count; i++) 
			{
				//skinFams[i] = new short[refCount];
				for (int j=0; j<refCount; j++) 
				{
					short skinRef = br.ReadInt16();
					//skinFams[i][j]=skinRef;
					skinFams[(i*refCount)+j] = skinRef;
					//Debug.Log ("skin family "+i+" ref "+j+" is "+skinRef);
				}
			}
			return skinFams;
		}

		//=============================================================================
		//===============================VVD===========================================
		//=============================================================================


		public void ParseVvd(string path, Func<string, Stream> openFileCallback)
		{
            path = path.Replace (".mdl", ".vvd");

	
			//_vertArray = null;
			//_Normals = null;
			//_UV = null;
			
			BinaryReader BR = new BinaryReader (openFileCallback(path));
			
			/*vvdheader */vvdHeader = ReadVvdHeader (BR);
			
			//VvdHeader = header;


			vertexFileFixup[] fixupTable = null;
			if (vvdHeader.numFixup > 0) 
			{
				//Debug.Log ("VVD file have "+vvdHeader.numFixup +" fixups");
				BR.BaseStream.Seek(vvdHeader.fixupTableStart, SeekOrigin.Begin);
				
				fixupTable=new vertexFileFixup[vvdHeader.numFixup];
				
				for (int i=0; i<vvdHeader.numFixup; i++) 
				{
					fixupTable[i]=new vertexFileFixup(BR.ReadInt32(),BR.ReadInt32(),BR.ReadInt32());
				}
			}

			if (vvdHeader.numLODs > 0) 
			{
				vertCount = vvdHeader.numLODVertexes [lodLevel];
				//int vertCount = vvdHeader.numLODVertexes [0];
				//_vertArray = ParseFixup (BR, vvdHeader.fixupTableStart, vvdHeader.numFixup, vvdHeader.vertexDataStart, vvdHeader.tangentDataStart,
	            //    out _Normals, out _UV, vertCount);
				ReadVvdVertexes(BR,vvdHeader.vertexDataStart,vertCount,fixupTable);
//				Debug.Log("VertCount "+vertCount+" vertArrayLength "+vertArray.Length);
			}
			else
			{
				Debug.LogWarning("VVD file numLODs is 0");
			}

			BR.BaseStream.Dispose ();
		}

		vvdheader ReadVvdHeader(BinaryReader br)
		{
			vvdheader hdr = new vvdheader ();
			
			hdr.id = br.ReadChars(4);
			hdr.version = br.ReadInt32 ();
			hdr.checksum = br.ReadInt32 ();
			hdr.numLODs = br.ReadInt32 ();
	//		Debug.Log ("VDD header numLODs is "+hdr.numLODs);
			hdr.numLODVertexes = new int[]{ br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 (),
											br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 ()};
			hdr.numFixup = br.ReadInt32 ();
			hdr.fixupTableStart = br.ReadInt32 ();
			hdr.vertexDataStart = br.ReadInt32 ();
			hdr.tangentDataStart = br.ReadInt32 ();

			return hdr;
		}

		void ReadVvdVertexes(BinaryReader br, int vertOffs, int vertCount, vertexFileFixup[] fixupTable)
		{
			if (fixupTable == null) 
			{
				boneWeights = new BoneWeight[vertCount];
				vertArray = new Vector3[vertCount];
				Normals = new Vector3[vertCount];
				UV = new Vector2[vertCount];

				br.BaseStream.Seek (vertOffs, SeekOrigin.Begin);
				for (int i=0; i<vertCount; i++) 
				{
					BoneWeight bw = new BoneWeight ();
					bw.weight0 = br.ReadSingle ();
					bw.weight1 = br.ReadSingle ();
					bw.weight2 = br.ReadSingle ();
					bw.boneIndex0 = br.ReadByte ();
					bw.boneIndex1 = br.ReadByte ();
					bw.boneIndex2 = br.ReadByte ();
					/*numbones =*/br.ReadByte ();
					boneWeights [i] = bw;

					vertArray [i] = ConvertUtils.FlipVector (ConvertUtils.ReadVector3 (br)) * SourceImportConfig.WorldScale;
					Normals [i] = ConvertUtils.FlipVector (ConvertUtils.ReadVector3 (br));
					UV [i] = ConvertUtils.ReadVector2 (br);
				}
			}
			else
			{	
				List<Vector3> VertexView = new List<Vector3>();
				List<Vector3> NormalView = new List<Vector3>();
				List<Vector2> UVView = new List<Vector2>();
				List<BoneWeight> _boneWeights = new List<BoneWeight> ();
				//int target=0;
				//int vertexArrayOffset=0;

				for (int i=0; i<fixupTable.Length; i++) 
				{
					if(fixupTable[i].lod < lodLevel)
						continue;
					
					for (int j=0; j<fixupTable[i].numVertexes; j++) 
					{
						int vertexViewOffset=(int)(vertOffs+((fixupTable[i].sourceVertexID+j)*48));
						br.BaseStream.Seek(vertexViewOffset, SeekOrigin.Begin);
						
						//48 bytes
						BoneWeight bw = new BoneWeight ();
						bw.weight0 = br.ReadSingle ();
						bw.weight1 = br.ReadSingle ();
						bw.weight2 = br.ReadSingle ();
						bw.boneIndex0 = br.ReadByte ();
						bw.boneIndex1 = br.ReadByte ();
						bw.boneIndex2 = br.ReadByte ();
						/*numbones =*/br.ReadByte ();
						_boneWeights.Add (bw);
						
						VertexView.Add( ConvertUtils.FlipVector (ConvertUtils.ReadVector3 (br)) * SourceImportConfig.WorldScale);
						NormalView.Add (ConvertUtils.FlipVector (ConvertUtils.ReadVector3 (br)));
						UVView.Add (ConvertUtils.ReadVector2 (br));
						
						//vertexArrayOffset++;
					}
					//target += fixupTable[i].numVertexes;
				}
				Normals = NormalView.ToArray ();
				UV = UVView.ToArray ();
				boneWeights = _boneWeights.ToArray ();
				vertArray = VertexView.ToArray();
			}
		}

		/*Vector3[] ParseFixup(BinaryReader BR, int fixupOffs, int fixupCount,int VertexOffs,int tangetnOffs,
		                     out Vector3[] _Normals, out Vector2[] _UV, int vertCount)
		{
			List<Vector3> VertexView = new List<Vector3>();
			List<Vector3> NormalView = new List<Vector3>();
			List<Vector2> UVView = new List<Vector2>();
			List<BoneWeight> _boneWeights = new List<BoneWeight> ();
			_Normals = null;//new Vector3[vertCount];
			_UV = null;//new Vector2[vertCount];
			int vertexArrayOffset=0;
			vertexFileFixup[] fixupTable;

			if (fixupCount == 0) 
			{
				BR.BaseStream.Seek(VertexOffs, SeekOrigin.Begin);
				for (int i=0; i<vertCount; i++) 
				{
					//int vertexOffs = i*48;
					//BR.BaseStream.Seek(16,SeekOrigin.Current);
					BoneWeight bw = new BoneWeight();
					bw.weight0=BR.ReadSingle();
					bw.weight1=BR.ReadSingle();
					bw.weight2=BR.ReadSingle();
					bw.boneIndex0=BR.ReadByte();
					bw.boneIndex1=BR.ReadByte();
					bw.boneIndex2=BR.ReadByte();
					/*numbones = BR.ReadByte();
					_boneWeights.Add (bw);
					VertexView.Add (ConvertUtils.FlipVector(ConvertUtils.ReadVector3(BR))*Settings.Inst.worldScale);
					NormalView.Add (ConvertUtils.FlipVector(ConvertUtils.ReadVector3(BR)));
					UVView.Add (ConvertUtils.ReadVector2 (BR));
					//BR.BaseStream.Seek (8,SeekOrigin.Current);
					vertexArrayOffset++;
				}
			}
			else
			{
				//Debug.Log("FixupCount "+fixupCount+"\n"+
				//          "FixupOffs: "+fixupOffs);

				int target=0;
				fixupTable=new vertexFileFixup[fixupCount];

				BR.BaseStream.Seek(fixupOffs, SeekOrigin.Begin);
				for (int i=0; i<fixupCount; i++) 
				{
					fixupTable[i]=new vertexFileFixup(BR.ReadInt32(),BR.ReadInt32(),BR.ReadInt32());
					
					//Debug.Log ("Fixup LODs: "+fixupTable[i].lod);
					//Debug.Log ("sourceVertexID: "+fixupTable[i].sourceVertexID);
					//Debug.Log ("num vertices: "+fixupTable[i].numVertexes);
				}

				for (int i=0; i<fixupCount; i++) 
				{
					if(fixupTable[i].lod < lodLevel)
						continue;

					for (int j=0; j<fixupTable[i].numVertexes; j++) 
					{
						int vertexViewOffset=(int)(VertexOffs+((fixupTable[i].sourceVertexID+j)*48));
						BR.BaseStream.Seek(vertexViewOffset, SeekOrigin.Begin);

						//48 bytes
						//BR.BaseStream.Seek(16,SeekOrigin.Current);
						BoneWeight bw = new BoneWeight();
						bw.weight0=BR.ReadSingle();
						bw.weight1=BR.ReadSingle();
						bw.weight2=BR.ReadSingle();
						bw.boneIndex0=BR.ReadByte();
						bw.boneIndex1=BR.ReadByte();
						bw.boneIndex2=BR.ReadByte();
						/*numbones = BR.ReadByte();
						_boneWeights.Add (bw);
						VertexView.Add (ConvertUtils.FlipVector(ConvertUtils.ReadVector3(BR))*Settings.Inst.worldScale);
						NormalView.Add (ConvertUtils.FlipVector(ConvertUtils.ReadVector3(BR)));
						UVView.Add (new Vector2(BR.ReadSingle(),BR.ReadSingle()));

						vertexArrayOffset++;
					}
					target += fixupTable[i].numVertexes;
				}
			}
			_Normals = NormalView.ToArray ();
			_UV = UVView.ToArray ();
			boneWeights = _boneWeights.ToArray ();
			return VertexView.ToArray();
		}*/

		//============================================================
		//                        VTX
		//============================================================

		public void ParseVtx(string path, Func<string, Stream> openFileCallback)
		{
            path = path.Replace (".mdl", ".dx90.vtx");
	
			//_indexArray = null;
			
			BinaryReader BR = new BinaryReader (openFileCallback(path));
			
			/*vtxheader*/ vtxHeader = ReadVtxHeader (BR);
			
			//VtxHeader = header;

			if (vtxHeader.numLODs > 0) 
			{
				/*vtxBodypartHeader[]*/ vtxBodyParts = ReadVtxBodyParts (BR, vtxHeader.bodyPartOffset, vtxHeader.numBobyParts);
				indexArray = BuildIndices (vtxBodyParts);
			}
			BR.BaseStream.Dispose ();
		}

		vtxHeader ReadVtxHeader(BinaryReader BR)
		{
			vtxHeader hdr = new vtxHeader ();
			
			hdr.version = BR.ReadInt32 ();
			hdr.vertCacheSize=BR.ReadInt32 ();
			hdr.maxBonePerStrip=BR.ReadInt16 ();
			hdr.maxBonePerTri=BR.ReadInt16 ();
			hdr.maxBonePerVert=BR.ReadInt32 ();
			hdr.checksum = BR.ReadInt32 ();
			hdr.numLODs = BR.ReadInt32 ();
			hdr.materialReplacementListOffset=BR.ReadInt32 ();
			hdr.numBobyParts=BR.ReadInt32 ();
			hdr.bodyPartOffset=BR.ReadInt32 ();
			
			return hdr;
		}

		vtxBodypartHeader[] ReadVtxBodyParts (BinaryReader br, int offs,int count)
		{
			vtxBodypartHeader[] bp = new vtxBodypartHeader[count];
			
			for (int i=0; i<count; i++) 
			{
				br.BaseStream.Seek (offs+(i*8), SeekOrigin.Begin);
				bp[i] = new vtxBodypartHeader(br.ReadInt32 (),br.ReadInt32 ());
				if(bp[i].numModels>0)
				{
					bp[i].models = ReadVtxModels(br, offs+(i*8), bp[i]);
				}
				else
					Debug.LogWarning("VTX Body part "+ i+" models count is 0");
			}
			
			return bp;
		}

		vtxModelHeader[] ReadVtxModels(BinaryReader br, int offset, vtxBodypartHeader bodypart)
		{
			vtxModelHeader[] mh = new vtxModelHeader[bodypart.numModels];

			for (int i=0; i<bodypart.numModels; i++) 
			{
				br.BaseStream.Seek (bodypart.modelsOffset + offset + (i*8), SeekOrigin.Begin);
				mh[i] = new vtxModelHeader (br.ReadInt32 (), br.ReadInt32 ());
				if(mh[i].numLODs>0)
				{
					mh[i].lods = ReadVtxModelLods(br, bodypart.modelsOffset + offset + (i*8), mh[i],i);
				}
				else
					Debug.LogWarning("VTX model "+ i+" LODs count is 0");
			}
			return mh;
		}
		
		vtxModelLODheader[] ReadVtxModelLods(BinaryReader br, int offset, vtxModelHeader model,int modelIndex)
		{
			vtxModelLODheader[] mlods = new vtxModelLODheader[model.numLODs];
			for (int i=0; i<model.numLODs; i++) 
			{
				br.BaseStream.Seek (model.LODOffset + offset + (i*12), SeekOrigin.Begin);
				mlods[i] = new vtxModelLODheader (br.ReadInt32 (), br.ReadInt32 (),br.ReadSingle());
				if(mlods[i].numMeshes>0)
				{
					mlods[i].meshes = ReadVtxMeshes(br, model.LODOffset+ offset + (i*12), mlods[i]);
				}
				else
					Debug.LogWarning("VTX model "+modelIndex+" lod "+ i+" mesh count is 0"); 
			}
			return mlods;
		}
		
		vtxMeshHeader[] ReadVtxMeshes(BinaryReader br, int offset, vtxModelLODheader lod)
		{
			vtxMeshHeader[] ms = new vtxMeshHeader[lod.numMeshes];

			for (int i=0; i<lod.numMeshes; i++) 
			{
				br.BaseStream.Seek (lod.meshOffset + offset + (i*9), SeekOrigin.Begin);
				ms[i] = new vtxMeshHeader (br.ReadInt32 (), br.ReadInt32 (),br.ReadByte());

				if(ms[i].numStripGroups>0)
				{
					ms[i].stripGroups = ReadVtxStripGroups(br, lod.meshOffset+ offset + (i*9), ms[i]);
				}
				//else
				//	Debug.LogWarning("VTX mesh "+ i+" numStripGroups is 0");
			}
			return ms;
		}

		vtxStripGroupHeader[] ReadVtxStripGroups(BinaryReader br, int offset,vtxMeshHeader mesh)
		{
			vtxStripGroupHeader[] sg = new vtxStripGroupHeader[mesh.numStripGroups];

			for (int i=0; i<mesh.numStripGroups; i++) 
			{
				br.BaseStream.Seek (mesh.stripGroupHeaderOffset + offset + (i*25), SeekOrigin.Begin);
				sg[i] = new vtxStripGroupHeader (br.ReadInt32 (), br.ReadInt32 (),br.ReadInt32 (),
				                                   br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 (),br.ReadByte());
				//Debug.Log ("Strip group "+i+" vert count is "+sg[i].numVerts);
				if(sg[i].numVerts>0)
				{
					sg[i].verts = ReadVtxVerts(br, mesh.stripGroupHeaderOffset+ offset + (i*25),sg[i]);
				}
				if(sg[i].numIndices>0)
				{
					br.BaseStream.Seek (mesh.stripGroupHeaderOffset + offset + (i*25)+sg[i].indexOffs,SeekOrigin.Begin);
					for(int j=0; j<sg[i].numIndices;j++)
						sg[i].indexArray[j] = br.ReadUInt16();
				}
				if(sg[i].numStrips>0)
				{
					sg[i].strips = ReadVtxStrips(br, mesh.stripGroupHeaderOffset+ offset + (i*25), sg[i]);
				}
				//sg[i].strips = ReadStrips(br, mesh.stripGroupHeaderOffset+ offset + (i*25), sg[i]);
				//sg[i].verts = ReadVtxVerts(br, mesh.stripGroupHeaderOffset+ offset + (i*25),sg[i]);
				//br.BaseStream.Seek (mesh.stripGroupHeaderOffset + offset + (i*25)+sg[i].indexOffs,SeekOrigin.Begin);
				//for(int j=0; j<sg[i].numIndices;j++)
				//	sg[i].indexArray[j] = br.ReadUInt16();
			}
			return sg;
		}

		vtxVertex[] ReadVtxVerts(BinaryReader br, int offset, vtxStripGroupHeader stripGroup)
		{
			vtxVertex[] vs = new vtxVertex[stripGroup.numVerts];

			br.BaseStream.Seek (stripGroup.vertOffset + offset, SeekOrigin.Begin);

			for (int i=0; i<stripGroup.numVerts; i++) 
			{
				//br.BaseStream.Seek (stripGroup.vertOffset + offset + (i*9), SeekOrigin.Begin);
				vs[i] = new vtxVertex (br.ReadBytes(3), br.ReadByte(),br.ReadUInt16(), br.ReadBytes(3));
			}
			return vs;
		}
		
		vtxStripHeader[] ReadVtxStrips(BinaryReader br, int offset, vtxStripGroupHeader stripGroup)
		{
			vtxStripHeader[] st = new vtxStripHeader[stripGroup.numStrips];

			br.BaseStream.Seek (stripGroup.stripOffset + offset, SeekOrigin.Begin);

			for (int i=0; i<stripGroup.numStrips; i++) 
			{
				//br.BaseStream.Seek (stripGroup.stripOffset + offset + (i*25), SeekOrigin.Begin);
				st[i] = new vtxStripHeader (br.ReadInt32 (), br.ReadInt32 (),br.ReadInt32 (),br.ReadInt32 (),
				                              br.ReadInt16 (), br.ReadByte(), br.ReadInt32(), br.ReadInt32());
			}
			return st;
		}

		int[] BuildIndices(vtxBodypartHeader[] bodyParts)
		{
			if (lodLevel >= vvdHeader.numLODs)
				lodLevel = (vvdHeader.numLODs - 1);
			int indexCount = IterateStripGroups (lodLevel, bodyParts[0]);
//			Debug.Log ("indexCount "+indexCount);
			int[] indices=new int[indexCount];
			int indexOffset=0;
			submeshCount = 0;

			//for(int bpId=0; bpId<bodyParts.Length; bpId++)
			//{
			int bpId=0;
				//Debug.Log("Bp "+bpId+" indexOffset "+indexOffset);
				vtxBodypartHeader vtxBodypart=bodyParts[bpId];
				//studiobodypart mdlBodypart = mdlBodyParts[bpId];
				for(int modelId=0; modelId<vtxBodypart.models.Length; modelId++)
				{
					vtxModelHeader vtxModel = vtxBodypart.models[modelId];
					studiomodel mdlModel=mdlBodyParts[bpId].models[modelId];

					if(lodLevel!=-1)
					{
						vtxModelLODheader _lod = vtxModel.lods[lodLevel];
						//Debug.Log ("Lod meshes "+_lod.meshes.Length);
						for(int meshId=0; meshId<_lod.numMeshes; meshId++)
						{
							vtxMeshHeader vtxMesh=_lod.meshes[meshId];
							studiomesh mdlMesh=mdlModel.meshes[meshId];

							for(int stripGroupId=0; stripGroupId<vtxMesh.numStripGroups; stripGroupId++)
							{
								vtxStripGroupHeader stripGroup=vtxMesh.stripGroups[stripGroupId];
								vtxVertex[] vertTable = stripGroup.verts;

								for(int i=0; i<stripGroup.numIndices;i++)
								{
									int vertTableIndex=stripGroup.indexArray[i];
									int index = vertTable[vertTableIndex].origMeshVertID + mdlModel.verticesoffs + mdlMesh.vertexoffs;
									//Debug.Log ("Index "+index);
									if(index<vertCount)//40500)
										indices[indexOffset]=index;
									else
										indices[indexOffset]=0;
									indexOffset++;
								}
								//submeshCount+=stripGroup.numStrips;
								//submeshCount++;
							}
							submeshCount++;
						}
					}
					else
						Debug.LogWarning("Lod level is -1");
				}
			//}
			return indices;
		}

		/*int[] BuildIndices(vtxBodypartHeader vtxBodyPart, int mdlbpindex)
		{
			if (lodLevel >= vvdHeader.numLODs)
				lodLevel = (vvdHeader.numLODs - 1);
			int indexCount = IterateStripGroups (lodLevel, vtxBodyPart);
			//Debug.Log ("indexCount "+indexCount);
			int[] indices=new int[indexCount];
			int indexOffset=0;

			//studiobodypart mdlBodypart = mdlBodyParts[bpId];
			for(int modelId=0; modelId<vtxBodyPart.models.Length; modelId++)
			{
				vtxModelHeader vtxModel = vtxBodyPart.models[modelId];
				studiomodel mdlModel=mdlBodyParts[mdlbpindex].models[modelId];

				if(lodLevel!=-1)
				{
					vtxModelLODheader _lod = vtxModel.lods[lodLevel];
					for(int meshId=0; meshId<_lod.numMeshes; meshId++)
					{
						vtxMeshHeader vtxMesh=_lod.meshes[meshId];
						studiomesh mdlMesh=mdlModel.meshes[meshId];
						
						for(int stripGroupId=0; stripGroupId<vtxMesh.numStripGroups; stripGroupId++)
						{
							vtxStripGroupHeader stripGroup=vtxMesh.stripGroups[stripGroupId];
							vtxVertex[] vertTable = stripGroup.verts;
							
							for(int i=0; i<stripGroup.numIndices;i++)
							{
								int vertTableIndex=stripGroup.indexArray[i];
								int index = vertTable[vertTableIndex].origMeshVertID + mdlModel.verticesoffs + mdlMesh.vertexoffs;
								//Debug.Log ("Index "+index);
								if(index<40500)
									indices[indexOffset]=index;
								else
									indices[indexOffset]=0;
								indexOffset++;
							}
						}
					}
				}
				else
					Debug.LogWarning("Lod level is -1");
			}
			
			return indices;
		}*/

		int IterateStripGroups(int lodID, vtxBodypartHeader bodyPart)
		{
			int indices=0;

			foreach(vtxModelHeader model in bodyPart.models)
			{
				if(lodID!=-1&&model.lods.Length>0)
				{
					vtxModelLODheader lodheader=model.lods[lodID];
					foreach(vtxMeshHeader mesh in lodheader.meshes)
					{
						foreach(vtxStripGroupHeader stripGroup in mesh.stripGroups)
						{
							//Debug.Log ("Strip group num indices "+stripGroup.numIndices);
							indices+=stripGroup.numIndices;
						}
					}
				}
				else
				{
					Debug.LogWarning ("model.lods.Length < 0 or lodID is -1");
				}
			}
			return indices;
		}
	}

}