#include "Object.h" #include #define PI (4.0*atan(1.0)) ///////////////////////////////////////////////////////////////////////// // public constructor/destructor Object::Object(const char* path) { // open file fsMesh.open(path, std::ios::in | std::ios::binary); if (!fsMesh.is_open()) throw std::invalid_argument(std::string("file not found: ") += path); // jump to file size information fsMesh.seekg(4); std::uint32_t tempFileSize; std::list tempMainChunks; // get all chunks under HEDR fsMesh.read(reinterpret_cast(&tempFileSize), sizeof(tempFileSize)); loadChunks(tempMainChunks, fsMesh.tellg(), tempFileSize); // evaluate HEDR subchunks (= find MSH2) for (std::list::iterator it = tempMainChunks.begin(); it != tempMainChunks.end(); it++) { if (!strcmp("MSH2", (*it)->name)) { // get all subchunks std::list tempMsh2Chunks; loadChunks(tempMsh2Chunks, (*it)->position, (*it)->size); // evaluate MSH2 subchunks analyseMsh2Chunks(tempMsh2Chunks); // clean up while (!tempMsh2Chunks.empty()) { ChunkHeader* tempCursor = tempMsh2Chunks.front(); tempMsh2Chunks.pop_front(); delete tempCursor; } continue; } } // clean up while (!tempMainChunks.empty()) { ChunkHeader* tempCursor = tempMainChunks.front(); tempMainChunks.pop_front(); delete tempCursor; } // close file fsMesh.close(); } Object::~Object() { // clear texture list vTextures.clear(); // clear Model list (don't delete the elements) vModls.clear(); } ///////////////////////////////////////////////////////////////////////// // private functions void Object::loadChunks(std::list& destination, std::streampos start, const std::uint32_t end) { // jump to first chunk fsMesh.seekg(start); do { ChunkHeader* tempHeader = new ChunkHeader(); fsMesh.read(reinterpret_cast(&tempHeader->name[0]), sizeof(tempHeader->name) - 1); fsMesh.read(reinterpret_cast(&tempHeader->size), sizeof(tempHeader->size)); tempHeader->position = fsMesh.tellg(); destination.push_back(tempHeader); fsMesh.seekg(tempHeader->size, std::ios_base::cur); // reached end if (fsMesh.tellg() - start == end) break; // error. Maybe the size information is corrupted if (!fsMesh.good()) { std::cout << "WARNING: corrupted file. Trying to continue" << std::endl; fsMesh.clear(); break; } } while (true); } void Object::analyseMsh2Chunks(std::list& chunkList) { for (std::list::iterator it = chunkList.begin(); it != chunkList.end(); it++) { if (!strcmp("MATL", (*it)->name)) { // "useless" information how many MATD follow fsMesh.seekg((*it)->position); std::uint32_t tempMatdCount; fsMesh.read(reinterpret_cast(&tempMatdCount), sizeof(std::uint32_t)); // get all MATD from MATL list std::list tempMatlChunks; loadChunks(tempMatlChunks, fsMesh.tellg(), (*it)->size - 4); // evaluate MATL subchunks for (std::list::iterator it = tempMatlChunks.begin(); it != tempMatlChunks.end(); it++) { // This shouldn't be anything else than MATD if (!strcmp("MATD", (*it)->name)) { // get all subchunks from MATD std::list tempMatdChunks; loadChunks(tempMatdChunks, (*it)->position, (*it)->size); // analyse MATD subchunks analyseMatdChunks(tempMatdChunks); // clean up while (!tempMatdChunks.empty()) { ChunkHeader* tempCursor = tempMatdChunks.front(); tempMatdChunks.pop_front(); delete tempCursor; } } } // clean up while (!tempMatlChunks.empty()) { ChunkHeader* tempCursor = tempMatlChunks.front(); tempMatlChunks.pop_front(); delete tempCursor; } continue; } if (!strcmp("MODL", (*it)->name)) { Modl* tempModl = new Modl; // get all subchunks std::list tempChunks; loadChunks(tempChunks, (*it)->position, (*it)->size); // evaluate MODL subchunks analyseModlChunks(tempModl, tempChunks); //clean up while (!tempChunks.empty()) { ChunkHeader* tempCursor = tempChunks.front(); tempChunks.pop_front(); delete tempCursor; } // save Model data vModls.push_back(tempModl); continue; } } } void Object::analyseMatdChunks(std::list& chunkList) { for (std::list::iterator it = chunkList.begin(); it != chunkList.end(); it++) { //TX1D, TX2D, TX3D if (!strcmp("TX0D", (*it)->name)) { fsMesh.seekg((*it)->position); char* buffer = new char[(*it)->size + 1]; *buffer = { 0 }; fsMesh.read(buffer, (*it)->size); vTextures.push_back(buffer); delete buffer; continue; } } } void Object::analyseModlChunks(Modl* dataDestination, std::list& chunkList) { for (std::list::iterator it = chunkList.begin(); it != chunkList.end(); it++) { if (!strcmp("MTYP", (*it)->name)) { fsMesh.seekg((*it)->position); std::uint32_t tempType; fsMesh.read(reinterpret_cast(&tempType), sizeof(tempType)); dataDestination->type = (Mtyp)tempType; continue; } if (!strcmp("PRNT", (*it)->name)) { fsMesh.seekg((*it)->position); char* buffer = new char[(*it)->size]; *buffer = { 0 }; fsMesh.read(buffer, (*it)->size); dataDestination->parent = buffer; delete buffer; continue; } if (!strcmp("NAME", (*it)->name)) { fsMesh.seekg((*it)->position); char* buffer = new char[(*it)->size]; *buffer = { 0 }; fsMesh.read(buffer, (*it)->size); dataDestination->name = buffer; delete buffer; continue; } if (!strcmp("FLGS", (*it)->name)) { fsMesh.seekg((*it)->position); fsMesh.read(reinterpret_cast(&dataDestination->renderFlags), sizeof(dataDestination->renderFlags)); continue; } if (!strcmp("TRAN", (*it)->name)) { float tempScale[3]; float tempRotation[4]; float tempTrans[3]; fsMesh.seekg((*it)->position); fsMesh.read(reinterpret_cast(&tempScale[0]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempScale[1]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempScale[2]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempRotation[0]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempRotation[1]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempRotation[2]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempRotation[3]), sizeof(float)); //calculate x,y,z rotation tempRotation[0] = atan2(2 * (tempRotation[0] * tempRotation[1] + tempRotation[2] * tempRotation[3]), 1 - 2 * (pow(tempRotation[1], 2) + pow(tempRotation[2], 2))); tempRotation[1] = asin(2 * (tempRotation[0] * tempRotation[2] - tempRotation[3] * tempRotation[1])); tempRotation[2] = atan2(2 * (tempRotation[0] * tempRotation[3] + tempRotation[1] * tempRotation[2]), 1 - 2 * (pow(tempRotation[2], 2) + pow(tempRotation[3], 2))) - PI; fsMesh.read(reinterpret_cast(&tempTrans[0]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempTrans[1]), sizeof(float)); fsMesh.read(reinterpret_cast(&tempTrans[2]), sizeof(float)); dataDestination->m4x4Translation = glm::scale( dataDestination->m4x4Translation, glm::vec3(tempScale[0], tempScale[1], tempScale[2]) ); dataDestination->m4x4Translation = glm::translate( dataDestination->m4x4Translation, glm::vec3(tempTrans[0], tempTrans[1], tempTrans[2]) ); dataDestination->m4x4Translation = glm::rotate( dataDestination->m4x4Translation, tempRotation[0], glm::vec3(1, 0, 0) ); dataDestination->m4x4Translation = glm::rotate( dataDestination->m4x4Translation, tempRotation[1], glm::vec3(0, 1, 0) ); dataDestination->m4x4Translation = glm::rotate( dataDestination->m4x4Translation, tempRotation[2], glm::vec3(0, 0, 1) ); continue; } if (!strcmp("GEOM", (*it)->name)) { // get all subchunks std::list tempGeomChunks; loadChunks(tempGeomChunks, (*it)->position, (*it)->size); // evaluate GEOM subchunks analyseGeomChunks(dataDestination, tempGeomChunks); // clean up while (!tempGeomChunks.empty()) { ChunkHeader* tempCursor = tempGeomChunks.front(); tempGeomChunks.pop_front(); delete tempCursor; } continue; } } } void Object::analyseGeomChunks(Modl * dataDestination, std::list& chunkList) { for (std::list::iterator it = chunkList.begin(); it != chunkList.end(); it++) { if (!strcmp("SEGM", (*it)->name)) { // get all subchunks std::list tempSegmChunks; loadChunks(tempSegmChunks, (*it)->position, (*it)->size); // evaluate SEGM subchunks analyseSegmChunks(dataDestination, tempSegmChunks); // clean up while (!tempSegmChunks.empty()) { ChunkHeader* tempCursor = tempSegmChunks.front(); tempSegmChunks.pop_front(); delete tempCursor; } continue; } if (!strcmp("CLTH", (*it)->name)) { // get all subchunks std::list tempClthChunks; loadChunks(tempClthChunks, (*it)->position, (*it)->size); // evaluate CLTH subchunks analyseClthChunks(dataDestination, tempClthChunks); // clean up while (!tempClthChunks.empty()) { ChunkHeader* tempCursor = tempClthChunks.front(); tempClthChunks.pop_front(); delete tempCursor; } continue; } } } void Object::analyseSegmChunks(Modl * dataDestination, std::list& chunkList) { Segment* tempData = new Segment; for (std::list::iterator it = chunkList.begin(); it != chunkList.end(); it++) { if (!strcmp("MATI", (*it)->name)) { fsMesh.seekg((*it)->position); fsMesh.read(reinterpret_cast(&tempData->textureIndex), sizeof(tempData->textureIndex)); continue; } if (!strcmp("POSL", (*it)->name)) { readVertex(tempData, (*it)->position); continue; } /*if (!strcmp("NRML", (*it)->name)) { fsMesh.seekg((*it)->position); // List of normals // long int - 4 - number of normal vectores stored in this list // float[3][] - 12 each - UVW vector for each vertex continue; }*/ if (!strcmp("UV0L", (*it)->name)) { readUV(tempData, (*it)->position); continue; } if (!strcmp("STRP", (*it)->name)) { // don't get null, bone, shadowMesh and hidden mesh indices if (dataDestination->type == null || dataDestination->type == bone || dataDestination->type == shadowMesh || dataDestination->renderFlags == 1) continue; // jump to the data section and read the size; std::uint32_t tempSize; fsMesh.seekg((*it)->position); fsMesh.read(reinterpret_cast(&tempSize), sizeof(tempSize)); int highBitCount(0); std::vector* tempPoly = new std::vector; for (unsigned int i = 0; i < tempSize; i++) { // ReadData std::uint16_t tempValue; fsMesh.read(reinterpret_cast(&tempValue), sizeof(std::uint16_t)); // Check for highbit if (tempValue >> 15) { highBitCount++; tempValue = (std::uint16_t(tempValue << 1) >> 1); } tempPoly->push_back((std::uint32_t)tempValue); // new Polygon found if (highBitCount == 2) { // reset highBitCount highBitCount = 0; // remove the last two values.. std::uint32_t saveData[2]; for (int i = 0; i < 2; i++) { saveData[i] = tempPoly->back(); tempPoly->pop_back(); } // ..and save them in the new vector std::vector* newPointer = new std::vector; for (int i = 1; i >= 0; i--) newPointer->push_back(saveData[i]); // save the old vector and set the pointer to the new one tempData->meshIndices.push_back(tempPoly); tempPoly = newPointer; } // if high bit set } // for all values // save the last values (where no 2 high bits follow); tempData->meshIndices.push_back(tempPoly); // kick the first element, it's empty as a reason of the algo above; tempData->meshIndices.erase(tempData->meshIndices.begin()); continue; } } dataDestination->segmLst.push_back(tempData); } void Object::analyseClthChunks(Modl * dataDestination, std::list& chunkList) { Segment* tempData = new Segment; for (std::list::iterator it = chunkList.begin(); it != chunkList.end(); it++) { if (!strcmp("CTEX", (*it)->name)) { fsMesh.seekg((*it)->position); char* buffer = new char[(*it)->size]; *buffer = { 0 }; fsMesh.read(buffer, (*it)->size); bool tempFound(false); for (unsigned int index = 0; index < vTextures.size(); index++) { if (!strcmp(buffer, vTextures[index].c_str())) { tempData->textureIndex = index; tempFound = true; break; } } if (!tempFound) { vTextures.push_back(std::string(buffer)); tempData->textureIndex = vTextures.size() - 1; } delete buffer; continue; } if (!strcmp("CPOS", (*it)->name)) { readVertex(tempData, (*it)->position); continue; } if (!strcmp("CUV0", (*it)->name)) { readUV(tempData, (*it)->position); continue; } if (!strcmp("CMSH", (*it)->name)) { // jump to the data section and read the size; std::uint32_t tempSize; fsMesh.seekg((*it)->position); fsMesh.read(reinterpret_cast(&tempSize), sizeof(tempSize)); std::vector* tempPoly; // for every triangle.. for (unsigned int i = 0; i < tempSize; i += 3) { tempPoly = new std::vector; // ..get the 3 indices and save them for (int j = 0; j < 3; j++) { std::uint32_t tempValue; fsMesh.read(reinterpret_cast(&tempValue), sizeof(std::uint32_t)); tempPoly->push_back(tempValue); } tempData->meshIndices.push_back(tempPoly); } continue; } } dataDestination->segmLst.push_back(tempData); } void Object::readVertex(Segment* dataDestination, std::streampos position) { std::uint32_t tempSize; fsMesh.seekg(position); fsMesh.read(reinterpret_cast(&tempSize), sizeof(tempSize)); dataDestination->vertex = new float[tempSize * 3]; for (unsigned int i = 0; i < tempSize * 3; i++) fsMesh.read(reinterpret_cast(&dataDestination->vertex[i]), sizeof(float)); } void Object::readUV(Segment* dataDestination, std::streampos position) { std::uint32_t tempSize; fsMesh.seekg(position); fsMesh.read(reinterpret_cast(&tempSize), sizeof(tempSize)); dataDestination->uv = new float[tempSize * 2]; for (unsigned int i = 0; i < tempSize * 2; i++) fsMesh.read(reinterpret_cast(&dataDestination->uv[i]), sizeof(float)); } ///////////////////////////////////////////////////////////////////////// // public getter std::vector Object::getModels() const { return vModls; } std::vector Object::getTextureList() const { return vTextures; } ///////////////////////////////////////////////////////////////////////// // public functions