#include "stdafx.h"
#include "ModelImporter.h"

#include <fstream>
#include <algorithm>

using namespace std;
using namespace wiGraphicsTypes;
using namespace wiSceneSystem;
using namespace wiECS;


//Mesh* LoadMeshFromBinaryFile(const std::string& newName, const std::string& fname, const std::map<std::string, Material*>& materialColl, const unordered_set<Armature*>& armatures)
//{
//	Mesh* mesh = new Mesh(newName);
//
//	BYTE* buffer;
//	size_t fileSize;
//	if (wiHelper::readByteData(fname, &buffer, fileSize)) {
//
//		int offset = 0;
//
//		int VERSION;
//		memcpy(&VERSION, buffer, sizeof(int));
//		offset += sizeof(int);
//
//		if (VERSION >= 1001) {
//			int doubleside;
//			memcpy(&doubleside, buffer + offset, sizeof(int));
//			offset += sizeof(int);
//			if (doubleside) {
//				mesh->doubleSided = true;
//			}
//		}
//
//		int billboard;
//		memcpy(&billboard, buffer + offset, sizeof(int));
//		offset += sizeof(int);
//		if (billboard) {
//			char axis;
//			memcpy(&axis, buffer + offset, 1);
//			offset += 1;
//
//			if (toupper(axis) == 'Y')
//				mesh->billboardAxis = XMFLOAT3(0, 1, 0);
//			else if (toupper(axis) == 'X')
//				mesh->billboardAxis = XMFLOAT3(1, 0, 0);
//			else if (toupper(axis) == 'Z')
//				mesh->billboardAxis = XMFLOAT3(0, 0, 1);
//			else
//				mesh->billboardAxis = XMFLOAT3(0, 0, 0);
//			mesh->isBillboarded = true;
//		}
//
//		int parented; //parentnamelength
//		memcpy(&parented, buffer + offset, sizeof(int));
//		offset += sizeof(int);
//		if (parented) {
//			char* pName = new char[parented + 1]();
//			memcpy(pName, buffer + offset, parented);
//			offset += parented;
//			mesh->parent = pName;
//			delete[] pName;
//
//			stringstream identified_parent("");
//			identified_parent << mesh->parent;
//			for (Armature* a : armatures) {
//				if (!a->name.compare(identified_parent.str())) {
//					mesh->armatureName = identified_parent.str();
//					mesh->armature = a;
//				}
//			}
//		}
//
//		int materialCount;
//		memcpy(&materialCount, buffer + offset, sizeof(int));
//		offset += sizeof(int);
//		for (int i = 0; i<materialCount; ++i) {
//			int matNameLen;
//			memcpy(&matNameLen, buffer + offset, sizeof(int));
//			offset += sizeof(int);
//			char* matName = new char[matNameLen + 1]();
//			memcpy(matName, buffer + offset, matNameLen);
//			offset += matNameLen;
//
//			stringstream identified_matname("");
//			identified_matname << matName;
//			auto& iter = materialColl.find(identified_matname.str());
//			if (iter != materialColl.end()) {
//				mesh->subsets.push_back(MeshSubset());
//				mesh->subsets.back().material = iter->second;
//				//materials.push_back(iter->second);
//			}
//
//			mesh->materialNames.push_back(identified_matname.str());
//			delete[] matName;
//		}
//		int rendermesh, vertexCount;
//		memcpy(&rendermesh, buffer + offset, sizeof(int));
//		offset += sizeof(int);
//		memcpy(&vertexCount, buffer + offset, sizeof(int));
//		offset += sizeof(int);
//
//		mesh->vertices_FULL.resize(vertexCount);
//
//		for (int i = 0; i<vertexCount; ++i) {
//			float v[8];
//			memcpy(v, buffer + offset, sizeof(float) * 8);
//			offset += sizeof(float) * 8;
//			mesh->vertices_FULL[i].pos.x = v[0];
//			mesh->vertices_FULL[i].pos.y = v[1];
//			mesh->vertices_FULL[i].pos.z = v[2];
//			mesh->vertices_FULL[i].pos.w = 0;
//			if (!mesh->isBillboarded) {
//				mesh->vertices_FULL[i].nor.x = v[3];
//				mesh->vertices_FULL[i].nor.y = v[4];
//				mesh->vertices_FULL[i].nor.z = v[5];
//			}
//			else {
//				mesh->vertices_FULL[i].nor.x = mesh->billboardAxis.x;
//				mesh->vertices_FULL[i].nor.y = mesh->billboardAxis.y;
//				mesh->vertices_FULL[i].nor.z = mesh->billboardAxis.z;
//			}
//			mesh->vertices_FULL[i].tex.x = v[6];
//			mesh->vertices_FULL[i].tex.y = v[7];
//			int matIndex;
//			memcpy(&matIndex, buffer + offset, sizeof(int));
//			offset += sizeof(int);
//			mesh->vertices_FULL[i].tex.z = (float)matIndex;
//
//			int weightCount = 0;
//			memcpy(&weightCount, buffer + offset, sizeof(int));
//			offset += sizeof(int);
//			for (int j = 0; j<weightCount; ++j) {
//
//				int weightNameLen = 0;
//				memcpy(&weightNameLen, buffer + offset, sizeof(int));
//				offset += sizeof(int);
//				char* weightName = new char[weightNameLen + 1](); //bone name
//				memcpy(weightName, buffer + offset, weightNameLen);
//				offset += weightNameLen;
//				float weightValue = 0;
//				memcpy(&weightValue, buffer + offset, sizeof(float));
//				offset += sizeof(float);
//
//#pragma region BONE INDEX SETUP
//				string nameB = weightName;
//				if (mesh->armature) {
//					bool gotBone = false;
//					int BONEINDEX = 0;
//					int b = 0;
//					while (!gotBone && b<(int)mesh->armature->boneCollection.size()) {
//						if (!mesh->armature->boneCollection[b]->name.compare(nameB)) {
//							gotBone = true;
//							BONEINDEX = b; //GOT INDEX OF BONE OF THE WEIGHT IN THE PARENT ARMATURE
//						}
//						b++;
//					}
//					if (gotBone) { //ONLY PROCEED IF CORRESPONDING BONE WAS FOUND
//						if (!mesh->vertices_FULL[i].wei.x) {
//							mesh->vertices_FULL[i].wei.x = weightValue;
//							mesh->vertices_FULL[i].ind.x = (float)BONEINDEX;
//						}
//						else if (!mesh->vertices_FULL[i].wei.y) {
//							mesh->vertices_FULL[i].wei.y = weightValue;
//							mesh->vertices_FULL[i].ind.y = (float)BONEINDEX;
//						}
//						else if (!mesh->vertices_FULL[i].wei.z) {
//							mesh->vertices_FULL[i].wei.z = weightValue;
//							mesh->vertices_FULL[i].ind.z = (float)BONEINDEX;
//						}
//						else if (!mesh->vertices_FULL[i].wei.w) {
//							mesh->vertices_FULL[i].wei.w = weightValue;
//							mesh->vertices_FULL[i].ind.w = (float)BONEINDEX;
//						}
//					}
//				}
//
//				//(+RIBBONTRAIL SETUP)(+VERTEXGROUP SETUP)
//
//				if (nameB.find("trailbase") != string::npos)
//					mesh->trailInfo.base = i;
//				else if (nameB.find("trailtip") != string::npos)
//					mesh->trailInfo.tip = i;
//
//				bool windAffection = false;
//				if (nameB.find("wind") != string::npos)
//					windAffection = true;
//				bool gotvg = false;
//				for (unsigned int v = 0; v<mesh->vertexGroups.size(); ++v)
//					if (!nameB.compare(mesh->vertexGroups[v].name)) {
//						gotvg = true;
//						mesh->vertexGroups[v].addVertex(VertexRef(i, weightValue));
//						if (windAffection)
//							mesh->vertices_FULL[i].pos.w = weightValue;
//					}
//				if (!gotvg) {
//					mesh->vertexGroups.push_back(VertexGroup(nameB));
//					mesh->vertexGroups.back().addVertex(VertexRef(i, weightValue));
//					if (windAffection)
//						mesh->vertices_FULL[i].pos.w = weightValue;
//				}
//#pragma endregion
//
//				delete[] weightName;
//
//
//			}
//
//		}
//
//		if (rendermesh) {
//			int indexCount;
//			memcpy(&indexCount, buffer + offset, sizeof(int));
//			offset += sizeof(int);
//			unsigned int* indexArray = new unsigned int[indexCount];
//			memcpy(indexArray, buffer + offset, sizeof(unsigned int)*indexCount);
//			offset += sizeof(unsigned int)*indexCount;
//			mesh->indices.reserve(indexCount);
//			for (int i = 0; i<indexCount; ++i) {
//				mesh->indices.push_back(indexArray[i]);
//			}
//			delete[] indexArray;
//
//			int softBody;
//			memcpy(&softBody, buffer + offset, sizeof(int));
//			offset += sizeof(int);
//			if (softBody) {
//				int softCount[2]; //ind,vert
//				memcpy(softCount, buffer + offset, sizeof(int) * 2);
//				offset += sizeof(int) * 2;
//				unsigned int* softind = new unsigned int[softCount[0]];
//				memcpy(softind, buffer + offset, sizeof(unsigned int)*softCount[0]);
//				offset += sizeof(unsigned int)*softCount[0];
//				float* softvert = new float[softCount[1]];
//				memcpy(softvert, buffer + offset, sizeof(float)*softCount[1]);
//				offset += sizeof(float)*softCount[1];
//
//				mesh->physicsindices.reserve(softCount[0]);
//				mesh->physicsverts.reserve(softCount[1] / 3);
//				for (int i = 0; i<softCount[0]; ++i) {
//					mesh->physicsindices.push_back(softind[i]);
//				}
//				for (int i = 0; i<softCount[1]; i += 3) {
//					mesh->physicsverts.push_back(XMFLOAT3(softvert[i], softvert[i + 1], softvert[i + 2]));
//				}
//
//				delete[] softind;
//				delete[] softvert;
//			}
//			else {
//
//			}
//		}
//		else {
//
//		}
//
//		memcpy(mesh->aabb.corners, buffer + offset, sizeof(mesh->aabb.corners));
//		offset += sizeof(mesh->aabb.corners);
//
//		int isSoftbody;
//		memcpy(&isSoftbody, buffer + offset, sizeof(int));
//		offset += sizeof(int);
//		if (isSoftbody) {
//			float prop[2]; //mass,friction
//			memcpy(prop, buffer + offset, sizeof(float) * 2);
//			offset += sizeof(float) * 2;
//			mesh->softBody = true;
//			mesh->mass = prop[0];
//			mesh->friction = prop[1];
//			int vglenghts[3]; //goal,mass,soft
//			memcpy(vglenghts, buffer + offset, sizeof(int) * 3);
//			offset += sizeof(int) * 3;
//
//			char* vgg = new char[vglenghts[0] + 1]();
//			char* vgm = new char[vglenghts[1] + 1]();
//			char* vgs = new char[vglenghts[2] + 1]();
//
//			memcpy(vgg, buffer + offset, vglenghts[0]);
//			offset += vglenghts[0];
//			memcpy(vgm, buffer + offset, vglenghts[1]);
//			offset += vglenghts[1];
//			memcpy(vgs, buffer + offset, vglenghts[2]);
//			offset += vglenghts[2];
//
//			for (unsigned int v = 0; v<mesh->vertexGroups.size(); ++v) {
//				if (!strcmp(vgm, mesh->vertexGroups[v].name.c_str()))
//					mesh->massVG = v;
//				if (!strcmp(vgg, mesh->vertexGroups[v].name.c_str()))
//					mesh->goalVG = v;
//				if (!strcmp(vgs, mesh->vertexGroups[v].name.c_str()))
//					mesh->softVG = v;
//			}
//
//			delete[]vgg;
//			delete[]vgm;
//			delete[]vgs;
//		}
//
//		delete[] buffer;
//
//		mesh->renderable = rendermesh == 0 ? false : true;
//	}
//
//	return mesh;
//}
//
//void LoadWiArmatures(const std::string& directory, const std::string& name, unordered_set<Armature*>& armatures)
//{
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file)
//	{
//		Armature* armature = nullptr;
//		while (!file.eof())
//		{
//			float trans[] = { 0,0,0,0 };
//			string line = "";
//			file >> line;
//			if (line[0] == '/' && line.substr(2, 8) == "ARMATURE")
//			{
//				armature = new Armature(line.substr(11, strlen(line.c_str()) - 11));
//				armatures.insert(armature);
//			}
//			else
//			{
//				switch (line[0])
//				{
//				case 'r':
//					file >> trans[0] >> trans[1] >> trans[2] >> trans[3];
//					armature->rotation_rest = XMFLOAT4(trans[0], trans[1], trans[2], trans[3]);
//					break;
//				case 's':
//					file >> trans[0] >> trans[1] >> trans[2];
//					armature->scale_rest = XMFLOAT3(trans[0], trans[1], trans[2]);
//					break;
//				case 't':
//					file >> trans[0] >> trans[1] >> trans[2];
//					armature->translation_rest = XMFLOAT3(trans[0], trans[1], trans[2]);
//					//{
//					//	XMMATRIX world = XMMatrixScalingFromVector(XMLoadFloat3(&armature->scale))*XMMatrixRotationQuaternion(XMLoadFloat4(&armature->rotation))*XMMatrixTranslationFromVector(XMLoadFloat3(&armature->translation));
//					//	XMStoreFloat4x4(&armature->world_rest, world);
//					//}
//					break;
//				case 'b':
//				{
//					string boneName;
//					file >> boneName;
//					armature->boneCollection.push_back(new Bone(boneName));
//				}
//				break;
//				case 'p':
//					file >> armature->boneCollection.back()->parentName;
//					break;
//				case 'l':
//				{
//					float x = 0, y = 0, z = 0, w = 0;
//					file >> x >> y >> z >> w;
//					XMVECTOR quaternion = XMVectorSet(x, y, z, w);
//					file >> x >> y >> z;
//					XMVECTOR translation = XMVectorSet(x, y, z, 0);
//
//					XMMATRIX frame;
//					frame = XMMatrixRotationQuaternion(quaternion) * XMMatrixTranslationFromVector(translation);
//
//					XMStoreFloat3(&armature->boneCollection.back()->translation_rest, translation);
//					XMStoreFloat4(&armature->boneCollection.back()->rotation_rest, quaternion);
//					XMStoreFloat4x4(&armature->boneCollection.back()->world_rest, frame);
//					//XMStoreFloat4x4(&armature->boneCollection.back()->restInv,XMMatrixInverse(0,frame));
//
//				}
//				break;
//				case 'c':
//					armature->boneCollection.back()->connected = true;
//					break;
//				case 'h':
//					file >> armature->boneCollection.back()->length;
//					break;
//				default: break;
//				}
//			}
//		}
//	}
//	file.close();
//
//
//
//	//CREATE FAMILY
//	for (Armature* armature : armatures)
//	{
//		armature->UpdateTransform();
//		armature->CreateFamily();
//	}
//
//}
//void LoadWiMaterialLibrary(const std::string& directory, const std::string& name, const std::string& texturesDir, std::map<std::string, Material*>& materials)
//{
//	int materialI = (int)(materials.size() - 1);
//
//	Material* currentMat = NULL;
//
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file) {
//		while (!file.eof()) {
//			string line = "";
//			file >> line;
//			if (line[0] == '/' && !strcmp(line.substr(2, 8).c_str(), "MATERIAL")) {
//				if (currentMat)
//				{
//					currentMat->ConvertToPhysicallyBasedMaterial();
//					materials.insert(pair<string, Material*>(currentMat->name, currentMat));
//				}
//
//				currentMat = new Material(line.substr(11, strlen(line.c_str()) - 11));
//				materialI++;
//			}
//			else {
//				switch (line[0]) {
//				case 'd':
//					file >> currentMat->diffuseColor.x;
//					file >> currentMat->diffuseColor.y;
//					file >> currentMat->diffuseColor.z;
//					break;
//				case 'X':
//					currentMat->cast_shadow = false;
//					break;
//				case 'r':
//				{
//					string resourceName = "";
//					file >> resourceName;
//					stringstream ss("");
//					ss << directory << texturesDir << resourceName.c_str();
//					currentMat->surfaceMapName = ss.str();
//					currentMat->surfaceMap = (Texture2D*)wiResourceManager::GetGlobal()->add(ss.str());
//				}
//				break;
//				case 'n':
//				{
//					string resourceName = "";
//					file >> resourceName;
//					stringstream ss("");
//					ss << directory << texturesDir << resourceName.c_str();
//					currentMat->normalMapName = ss.str();
//					currentMat->normalMap = (Texture2D*)wiResourceManager::GetGlobal()->add(ss.str());
//				}
//				break;
//				case 't':
//				{
//					string resourceName = "";
//					file >> resourceName;
//					stringstream ss("");
//					ss << directory << texturesDir << resourceName.c_str();
//					currentMat->textureName = ss.str();
//					currentMat->texture = (Texture2D*)wiResourceManager::GetGlobal()->add(ss.str());
//				}
//				file >> currentMat->premultipliedTexture;
//				break;
//				case 'D':
//				{
//					string resourceName = "";
//					file >> resourceName;
//					stringstream ss("");
//					ss << directory << texturesDir << resourceName.c_str();
//					currentMat->displacementMapName = ss.str();
//					currentMat->displacementMap = (Texture2D*)wiResourceManager::GetGlobal()->add(ss.str());
//				}
//				break;
//				case 'S':
//				{
//					string resourceName = "";
//					file >> resourceName;
//					stringstream ss("");
//					ss << directory << texturesDir << resourceName.c_str();
//					currentMat->specularMapName = ss.str();
//					currentMat->specularMap = (Texture2D*)wiResourceManager::GetGlobal()->add(ss.str());
//				}
//				break;
//				case 'a':
//					file >> currentMat->alpha;
//					break;
//				case 'h':
//					currentMat->shadeless = true;
//					break;
//				case 'R':
//					file >> currentMat->refractionIndex;
//					break;
//				case 'e':
//					file >> currentMat->enviroReflection;
//					break;
//				case 's':
//					file >> currentMat->specular.x;
//					file >> currentMat->specular.y;
//					file >> currentMat->specular.z;
//					file >> currentMat->specular.w;
//					break;
//				case 'p':
//					file >> currentMat->specular_power;
//					break;
//				case 'k':
//					currentMat->isSky = true;
//					break;
//				case 'm':
//					file >> currentMat->movingTex.x;
//					file >> currentMat->movingTex.y;
//					file >> currentMat->movingTex.z;
//					currentMat->framesToWaitForTexCoordOffset = currentMat->movingTex.z;
//					break;
//				case 'w':
//					currentMat->water = true;
//					break;
//				case 'u':
//					currentMat->subsurfaceScattering = true;
//					break;
//				case 'b':
//				{
//					string blend;
//					file >> blend;
//					if (!blend.compare("ADD"))
//						currentMat->blendFlag = BLENDMODE_ADDITIVE;
//				}
//				break;
//				case 'i':
//				{
//					file >> currentMat->emissive;
//				}
//				break;
//				default:break;
//				}
//			}
//		}
//	}
//	file.close();
//
//	if (currentMat)
//	{
//		currentMat->ConvertToPhysicallyBasedMaterial();
//		materials.insert(pair<string, Material*>(currentMat->name, currentMat));
//	}
//
//}
//void LoadWiObjects(const std::string& directory, const std::string& name, unordered_set<Object*>& objects
//	, unordered_set<Armature*>& armatures
//	, std::map<std::string, Mesh*>& meshes, const std::map<std::string, Material*>& materials)
//{
//
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file)
//	{
//		Object* object = nullptr;
//		while (!file.eof())
//		{
//			float trans[] = { 0,0,0,0 };
//			string line = "";
//			file >> line;
//			if (line[0] == '/' && !strcmp(line.substr(2, 6).c_str(), "OBJECT"))
//			{
//				object = new Object(line.substr(9, strlen(line.c_str()) - 9));
//				objects.insert(object);
//			}
//			else
//			{
//				switch (line[0])
//				{
//				case 'm':
//				{
//					string meshName = "";
//					file >> meshName;
//					object->meshName = meshName;
//					auto& iter = meshes.find(meshName);
//
//					if (line[1] == 'b')
//					{
//						//binary load mesh in place if not present
//						if (iter == meshes.end())
//						{
//							stringstream meshFileName("");
//							meshFileName << directory << meshName << ".wimesh";
//							Mesh* mesh = LoadMeshFromBinaryFile(meshName, meshFileName.str(), materials, armatures);
//							object->mesh = mesh;
//							meshes.insert(pair<string, Mesh*>(meshName, mesh));
//						}
//						else
//						{
//							object->mesh = iter->second;
//						}
//					}
//					else
//					{
//						if (iter != meshes.end())
//						{
//							object->mesh = iter->second;
//						}
//					}
//				}
//				break;
//				case 'p':
//				{
//					file >> object->parentName;
//				}
//				break;
//				case 'b':
//				{
//					file >> object->boneParent;
//				}
//				break;
//				case 'I':
//				{
//					XMFLOAT3 s, t;
//					XMFLOAT4 r;
//					file >> t.x >> t.y >> t.z >> r.x >> r.y >> r.z >> r.w >> s.x >> s.y >> s.z;
//					XMStoreFloat4x4(&object->parent_inv_rest
//						, XMMatrixScalingFromVector(XMLoadFloat3(&s)) *
//						XMMatrixRotationQuaternion(XMLoadFloat4(&r)) *
//						XMMatrixTranslationFromVector(XMLoadFloat3(&t))
//					);
//				}
//				break;
//				case 'r':
//					file >> trans[0] >> trans[1] >> trans[2] >> trans[3];
//					object->Rotate(XMFLOAT4(trans[0], trans[1], trans[2], trans[3]));
//					break;
//				case 's':
//					file >> trans[0] >> trans[1] >> trans[2];
//					object->Scale(XMFLOAT3(trans[0], trans[1], trans[2]));
//					break;
//				case 't':
//					file >> trans[0] >> trans[1] >> trans[2];
//					object->Translate(XMFLOAT3(trans[0], trans[1], trans[2]));
//					break;
//				case 'E':
//				{
//					string systemName, materialName;
//					bool visibleEmitter;
//					float size, randfac, norfac;
//					float count, life, randlife;
//					float scaleX, scaleY, rot;
//					file >> systemName >> visibleEmitter >> materialName >> size >> randfac >> norfac >> count >> life >> randlife;
//					file >> scaleX >> scaleY >> rot;
//
//					if (object->mesh)
//					{
//						object->eParticleSystems.push_back(
//							new wiEmittedParticle(systemName, materialName, object, size, randfac, norfac, count, life, randlife, scaleX, scaleY, rot)
//						);
//					}
//				}
//				break;
//				case 'H':
//				{
//					string name, mat, densityG, lenG;
//					float len;
//					int count;
//					file >> name >> mat >> len >> count >> densityG >> lenG;
//
//					object->hParticleSystems.push_back(new wiHairParticle(name, len, count, mat, object, densityG, lenG));
//				}
//				break;
//				case 'P':
//					object->rigidBody = true;
//					file >> object->collisionShape >> object->mass >>
//						object->friction >> object->restitution >> object->damping >> object->physicsType >>
//						object->kinematic;
//					break;
//				case 'T':
//					file >> object->transparency;
//					break;
//				default: break;
//				}
//			}
//		}
//	}
//	file.close();
//
//}
//void LoadWiMeshes(const std::string& directory, const std::string& name, std::map<std::string, Mesh*>& meshes,
//	const unordered_set<Armature*>& armatures, const std::map<std::string, Material*>& materials)
//{
//	int meshI = (int)(meshes.size() - 1);
//	Mesh* currentMesh = NULL;
//
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file) {
//		while (!file.eof())
//		{
//			float trans[] = { 0,0,0,0 };
//			string line = "";
//			file >> line;
//			if (line[0] == '/' && !line.substr(2, 4).compare("MESH")) {
//				currentMesh = new Mesh(line.substr(7, strlen(line.c_str()) - 7));
//				meshes.insert(pair<string, Mesh*>(currentMesh->name, currentMesh));
//				meshI++;
//			}
//			else
//			{
//				switch (line[0])
//				{
//				case 'p':
//				{
//					file >> currentMesh->parent;
//					for (auto& a : armatures)
//					{
//						if (!a->name.compare(currentMesh->parent))
//						{
//							currentMesh->armature = a;
//							break;
//						}
//					}
//				}
//				break;
//				case 'v':
//					currentMesh->vertices_FULL.push_back(Mesh::Vertex_FULL());
//					file >> currentMesh->vertices_FULL.back().pos.x;
//					file >> currentMesh->vertices_FULL.back().pos.y;
//					file >> currentMesh->vertices_FULL.back().pos.z;
//					break;
//				case 'n':
//					if (currentMesh->isBillboarded) {
//						currentMesh->vertices_FULL.back().nor.x = currentMesh->billboardAxis.x;
//						currentMesh->vertices_FULL.back().nor.y = currentMesh->billboardAxis.y;
//						currentMesh->vertices_FULL.back().nor.z = currentMesh->billboardAxis.z;
//					}
//					else {
//						file >> currentMesh->vertices_FULL.back().nor.x;
//						file >> currentMesh->vertices_FULL.back().nor.y;
//						file >> currentMesh->vertices_FULL.back().nor.z;
//					}
//					break;
//				case 'u':
//					file >> currentMesh->vertices_FULL.back().tex.x;
//					file >> currentMesh->vertices_FULL.back().tex.y;
//					break;
//				case 'w':
//				{
//					string nameB;
//					float weight = 0;
//					int BONEINDEX = 0;
//					file >> nameB >> weight;
//					bool gotBone = false;
//					if (currentMesh->armature != nullptr) {
//						int j = 0;
//						for (auto& b : currentMesh->armature->boneCollection)
//						{
//							if (!b->name.compare(nameB))
//							{
//								BONEINDEX = j;
//								break;
//							}
//							j++;
//						}
//					}
//					if (gotBone)
//					{
//						//ONLY PROCEED IF CORRESPONDING BONE WAS FOUND
//						if (!currentMesh->vertices_FULL.back().wei.x) {
//							currentMesh->vertices_FULL.back().wei.x = weight;
//							currentMesh->vertices_FULL.back().ind.x = (float)BONEINDEX;
//						}
//						else if (!currentMesh->vertices_FULL.back().wei.y) {
//							currentMesh->vertices_FULL.back().wei.y = weight;
//							currentMesh->vertices_FULL.back().ind.y = (float)BONEINDEX;
//						}
//						else if (!currentMesh->vertices_FULL.back().wei.z) {
//							currentMesh->vertices_FULL.back().wei.z = weight;
//							currentMesh->vertices_FULL.back().ind.z = (float)BONEINDEX;
//						}
//						else if (!currentMesh->vertices_FULL.back().wei.w) {
//							currentMesh->vertices_FULL.back().wei.w = weight;
//							currentMesh->vertices_FULL.back().ind.w = (float)BONEINDEX;
//						}
//					}
//
//					//(+RIBBONTRAIL SETUP)(+VERTEXGROUP SETUP)
//
//					if (nameB.find("trailbase") != string::npos)
//						currentMesh->trailInfo.base = (int)(currentMesh->vertices_FULL.size() - 1);
//					else if (nameB.find("trailtip") != string::npos)
//						currentMesh->trailInfo.tip = (int)(currentMesh->vertices_FULL.size() - 1);
//
//					bool windAffection = false;
//					if (nameB.find("wind") != string::npos)
//						windAffection = true;
//					bool gotvg = false;
//					for (unsigned int v = 0; v<currentMesh->vertexGroups.size(); ++v)
//						if (!nameB.compare(currentMesh->vertexGroups[v].name)) {
//							gotvg = true;
//							currentMesh->vertexGroups[v].addVertex(VertexRef((int)(currentMesh->vertices_FULL.size() - 1), weight));
//							if (windAffection)
//								currentMesh->vertices_FULL.back().pos.w = weight;
//						}
//					if (!gotvg) {
//						currentMesh->vertexGroups.push_back(VertexGroup(nameB));
//						currentMesh->vertexGroups.back().addVertex(VertexRef((int)(currentMesh->vertices_FULL.size() - 1), weight));
//						if (windAffection)
//							currentMesh->vertices_FULL.back().pos.w = weight;
//					}
//				}
//				break;
//				case 'i':
//				{
//					int count;
//					file >> count;
//					for (int i = 0; i<count; i++) {
//						int index;
//						file >> index;
//						currentMesh->indices.push_back(index);
//					}
//					break;
//				}
//				case 'V':
//				{
//					XMFLOAT3 pos;
//					file >> pos.x >> pos.y >> pos.z;
//					currentMesh->physicsverts.push_back(pos);
//				}
//				break;
//				case 'I':
//				{
//					int count;
//					file >> count;
//					for (int i = 0; i<count; i++) {
//						int index;
//						file >> index;
//						currentMesh->physicsindices.push_back(index);
//					}
//					break;
//				}
//				case 'm':
//				{
//					string mName = "";
//					file >> mName;
//					currentMesh->materialNames.push_back(mName);
//					auto& iter = materials.find(mName);
//					if (iter != materials.end()) {
//						currentMesh->subsets.push_back(MeshSubset());
//						currentMesh->renderable = true;
//						currentMesh->subsets.back().material = (iter->second);
//					}
//				}
//				break;
//				case 'a':
//					file >> currentMesh->vertices_FULL.back().tex.z;
//					break;
//				case 'B':
//					for (int corner = 0; corner<8; ++corner) {
//						file >> currentMesh->aabb.corners[corner].x;
//						file >> currentMesh->aabb.corners[corner].y;
//						file >> currentMesh->aabb.corners[corner].z;
//					}
//					break;
//				case 'b':
//				{
//					currentMesh->isBillboarded = true;
//					string read = "";
//					file >> read;
//					transform(read.begin(), read.end(), read.begin(), toupper);
//					if (read.find(toupper('y')) != string::npos) currentMesh->billboardAxis = XMFLOAT3(0, 1, 0);
//					else if (read.find(toupper('x')) != string::npos) currentMesh->billboardAxis = XMFLOAT3(1, 0, 0);
//					else if (read.find(toupper('z')) != string::npos) currentMesh->billboardAxis = XMFLOAT3(0, 0, 1);
//					else currentMesh->billboardAxis = XMFLOAT3(0, 0, 0);
//				}
//				break;
//				case 'S':
//				{
//					currentMesh->softBody = true;
//					string mvgi = "", gvgi = "", svgi = "";
//					file >> currentMesh->mass >> currentMesh->friction >> gvgi >> mvgi >> svgi;
//					for (unsigned int v = 0; v<currentMesh->vertexGroups.size(); ++v) {
//						if (!strcmp(mvgi.c_str(), currentMesh->vertexGroups[v].name.c_str()))
//							currentMesh->massVG = v;
//						if (!strcmp(gvgi.c_str(), currentMesh->vertexGroups[v].name.c_str()))
//							currentMesh->goalVG = v;
//						if (!strcmp(svgi.c_str(), currentMesh->vertexGroups[v].name.c_str()))
//							currentMesh->softVG = v;
//					}
//				}
//				break;
//				default: break;
//				}
//			}
//		}
//	}
//	file.close();
//
//	if (currentMesh)
//		meshes.insert(pair<string, Mesh*>(currentMesh->name, currentMesh));
//
//}
//void LoadWiActions(const std::string& directory, const std::string& name, unordered_set<Armature*>& armatures)
//{
//	Armature* armatureI = nullptr;
//	Bone* boneI = nullptr;
//	int firstFrame = INT_MAX;
//
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file) {
//		while (!file.eof()) {
//			string line = "";
//			file >> line;
//			if (line[0] == '/' && !strcmp(line.substr(2, 8).c_str(), "ARMATURE")) {
//				string armaturename = line.substr(11, strlen(line.c_str()) - 11);
//				for (auto& a : armatures)
//				{
//					if (!a->name.compare(armaturename)) {
//						armatureI = a;
//						break;
//					}
//				}
//			}
//			else {
//				switch (line[0]) {
//				case 'C':
//					armatureI->actions.push_back(Action());
//					file >> armatureI->actions.back().name;
//					break;
//				case 'A':
//					file >> armatureI->actions.back().frameCount;
//					break;
//				case 'b':
//				{
//					string boneName;
//					file >> boneName;
//					boneI = armatureI->GetBone(boneName);
//					if (boneI != nullptr)
//					{
//						boneI->actionFrames.resize(armatureI->actions.size());
//					}
//				}
//				break;
//				case 'r':
//				{
//					int f = 0;
//					float x = 0, y = 0, z = 0, w = 0;
//					file >> f >> x >> y >> z >> w;
//					if (boneI != nullptr)
//					{
//						boneI->actionFrames.back().keyframesRot.push_back(KeyFrame(f, x, y, z, w));
//					}
//				}
//				break;
//				case 't':
//				{
//					int f = 0;
//					float x = 0, y = 0, z = 0;
//					file >> f >> x >> y >> z;
//					if (boneI != nullptr)
//					{
//						boneI->actionFrames.back().keyframesPos.push_back(KeyFrame(f, x, y, z, 0));
//					}
//				}
//				break;
//				case 's':
//				{
//					int f = 0;
//					float x = 0, y = 0, z = 0;
//					file >> f >> x >> y >> z;
//					if (boneI != nullptr)
//					{
//						boneI->actionFrames.back().keyframesSca.push_back(KeyFrame(f, x, y, z, 0));
//					}
//				}
//				break;
//				default: break;
//				}
//			}
//		}
//	}
//	file.close();
//}
//void LoadWiLights(const std::string& directory, const std::string& name, unordered_set<Light*>& lights)
//{
//
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file)
//	{
//		Light* light = nullptr;
//		while (!file.eof())
//		{
//			string line = "";
//			file >> line;
//			switch (line[0])
//			{
//			case 'P':
//			{
//				light = new Light();
//				lights.insert(light);
//				light->SetType(Light::POINT);
//				file >> light->name >> light->shadow;
//			}
//			break;
//			case 'D':
//			{
//				light = new Light();
//				lights.insert(light);
//				light->SetType(Light::DIRECTIONAL);
//				file >> light->name;
//				light->shadow = true;
//			}
//			break;
//			case 'S':
//			{
//				light = new Light();
//				lights.insert(light);
//				light->SetType(Light::SPOT);
//				file >> light->name;
//				file >> light->shadow >> light->enerDis.z;
//			}
//			break;
//			case 'p':
//			{
//				file >> light->parentName;
//			}
//			break;
//			case 'b':
//			{
//				file >> light->boneParent;
//			}
//			break;
//			case 'I':
//			{
//				XMFLOAT3 s, t;
//				XMFLOAT4 r;
//				file >> t.x >> t.y >> t.z >> r.x >> r.y >> r.z >> r.w >> s.x >> s.y >> s.z;
//				XMStoreFloat4x4(&light->parent_inv_rest
//					, XMMatrixScalingFromVector(XMLoadFloat3(&s)) *
//					XMMatrixRotationQuaternion(XMLoadFloat4(&r)) *
//					XMMatrixTranslationFromVector(XMLoadFloat3(&t))
//				);
//			}
//			break;
//			case 't':
//			{
//				float x, y, z;
//				file >> x >> y >> z;
//				light->Translate(XMFLOAT3(x, y, z));
//				break;
//			}
//			case 'r':
//			{
//				float x, y, z, w;
//				file >> x >> y >> z >> w;
//				light->Rotate(XMFLOAT4(x, y, z, w));
//				break;
//			}
//			case 'c':
//			{
//				float r, g, b;
//				file >> r >> g >> b;
//				light->color = XMFLOAT4(r, g, b, 0);
//				break;
//			}
//			case 'e':
//				file >> light->enerDis.x;
//				break;
//			case 'd':
//				file >> light->enerDis.y;
//				break;
//			case 'n':
//				light->noHalo = true;
//				break;
//			case 'l':
//			{
//				string t = "";
//				file >> t;
//				stringstream rim("");
//				rim << directory << "rims/" << t;
//				Texture2D* tex = nullptr;
//				if ((tex = (Texture2D*)wiResourceManager::GetGlobal()->add(rim.str())) != nullptr) {
//					light->lensFlareRimTextures.push_back(tex);
//					light->lensFlareNames.push_back(rim.str());
//				}
//			}
//			break;
//			default: break;
//			}
//		}
//
//	}
//	file.close();
//}
//void LoadWiCameras(const std::string&directory, const std::string& name, std::list<Camera*>& cameras
//	, const unordered_set<Armature*>& armatures)
//{
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file)
//	{
//		string voidStr("");
//		file >> voidStr;
//		while (!file.eof()) {
//			string line = "";
//			file >> line;
//			switch (line[0]) {
//
//			case 'c':
//			{
//				XMFLOAT3 trans;
//				XMFLOAT4 rot;
//				string name(""), parentA(""), parentB("");
//				file >> name >> parentA >> parentB >> trans.x >> trans.y >> trans.z >> rot.x >> rot.y >> rot.z >> rot.w;
//
//				cameras.push_back(new Camera(
//					trans, rot
//					, name)
//				);
//
//				for (auto& a : armatures)
//				{
//					Bone* b = a->GetBone(parentB);
//					if (b != nullptr)
//					{
//						cameras.back()->attachTo(b);
//					}
//				}
//
//			}
//			break;
//			case 'I':
//			{
//				XMFLOAT3 s, t;
//				XMFLOAT4 r;
//				file >> t.x >> t.y >> t.z >> r.x >> r.y >> r.z >> r.w >> s.x >> s.y >> s.z;
//				XMStoreFloat4x4(&cameras.back()->parent_inv_rest
//					, XMMatrixScalingFromVector(XMLoadFloat3(&s)) *
//					XMMatrixRotationQuaternion(XMLoadFloat4(&r)) *
//					XMMatrixTranslationFromVector(XMLoadFloat3(&t))
//				);
//			}
//			break;
//			default:break;
//			}
//		}
//	}
//	file.close();
//}
//void LoadWiDecals(const std::string&directory, const std::string& name, const std::string& texturesDir, unordered_set<Decal*>& decals)
//{
//	stringstream filename("");
//	filename << directory << name;
//
//	ifstream file(filename.str().c_str());
//	if (file)
//	{
//		Decal* decal = nullptr;
//		string voidStr = "";
//		file >> voidStr;
//		while (!file.eof())
//		{
//			string line = "";
//			file >> line;
//			switch (line[0])
//			{
//			case 'd':
//			{
//				string name;
//				XMFLOAT3 loc, scale;
//				XMFLOAT4 rot;
//				file >> name >> scale.x >> scale.y >> scale.z >> loc.x >> loc.y >> loc.z >> rot.x >> rot.y >> rot.z >> rot.w;
//				decal = new Decal(loc, scale, rot);
//				decal->name = name;
//				decals.insert(decal);
//			}
//			break;
//			case 't':
//			{
//				string tex = "";
//				file >> tex;
//				stringstream ss("");
//				ss << directory << texturesDir << tex;
//				decal->addTexture(ss.str());
//			}
//			break;
//			case 'n':
//			{
//				string tex = "";
//				file >> tex;
//				stringstream ss("");
//				ss << directory << texturesDir << tex;
//				decal->addNormal(ss.str());
//			}
//			break;
//			default:break;
//			};
//		}
//	}
//	file.close();
//}

Entity ImportModel_WIO(const std::string& fileName)
{
	string directory, name;
	wiHelper::SplitPath(fileName, directory, name);
	string extension = wiHelper::toUpper(wiHelper::GetExtensionFromFileName(name));
	wiHelper::RemoveExtensionFromFileName(name);

	return INVALID_ENTITY;

	//Model* model = new Model;
	//model->name = name;

	//stringstream armatureFilePath(""), materialLibFilePath(""), meshesFilePath(""), objectsFilePath("")
	//	, actionsFilePath(""), lightsFilePath(""), decalsFilePath(""), camerasFilePath("");

	//armatureFilePath << name << ".wia";
	//materialLibFilePath << name << ".wim";
	//meshesFilePath << name << ".wi";
	//objectsFilePath << name << ".wio";
	//actionsFilePath << name << ".wiact";
	//lightsFilePath << name << ".wil";
	//decalsFilePath << name << ".wid";
	//camerasFilePath << name << ".wic";

	//LoadWiArmatures(directory, armatureFilePath.str(), model->armatures);
	//LoadWiMaterialLibrary(directory, materialLibFilePath.str(), "textures/", model->materials);
	//LoadWiMeshes(directory, meshesFilePath.str(), model->meshes, model->armatures, model->materials);
	//LoadWiObjects(directory, objectsFilePath.str(), model->objects, model->armatures, model->meshes, model->materials);
	//LoadWiActions(directory, actionsFilePath.str(), model->armatures);
	//LoadWiLights(directory, lightsFilePath.str(), model->lights);
	//LoadWiDecals(directory, decalsFilePath.str(), "textures/", model->decals);
	//LoadWiCameras(directory, camerasFilePath.str(), model->cameras, model->armatures);

	//model->FinishLoading();

	//return model;
}