turanszkij
1245 lines
36 KiB
C++
1245 lines
36 KiB
C++
#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;
|
|
}
|