itdominator
/
SWBF2-Classic-Msh-Viewer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

changed everything from std to qt

This commit is contained in:
Anakin 2017-02-02 14:44:48 +01:00
parent 5372838420
commit 8346e5916d
4 changed files with 141 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
QtMeshViewer/Header/FileInterface.h
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <QOpenGlTexture> #include <QOpenGlTexture>
#include <fstream> #include <QFile>
#include <QVector> #include <QVector>
#include <QVector2D> #include <QVector2D>
#include <QMatrix4x4> #include <QMatrix4x4>
@ -21,17 +21,17 @@ struct VertexData
}; };
struct Segment { struct Segment {
std::uint32_t textureIndex = 0; quint32 textureIndex = 0;
QVector<VertexData> vertices; QVector<VertexData> vertices;
QVector<GLuint> indices; QVector<GLuint> indices;
}; };
struct Model { struct Model {
std::string name = ""; QString name = "";
std::string parent = ""; QString parent = "";
QMatrix4x4 m4x4Translation; QMatrix4x4 m4x4Translation;
QQuaternion quadRotation; QQuaternion quadRotation;
std::vector<Segment*> segmList; QVector<Segment*> segmList;
}; };
struct Material { struct Material {
@ -48,8 +48,8 @@ struct Material {
float shininess = 80; float shininess = 80;
bool flags[8] = { false }; bool flags[8] = { false };
bool transparent = false; bool transparent = false;
std::uint8_t rendertype = 0; quint8 rendertype = 0;
std::uint8_t dataValues[2] = { 0 }; quint8 dataValues[2] = { 0 };
}; };
class FileInterface class FileInterface
@ -61,9 +61,9 @@ public:
, m_materials(new QVector<Material>) , m_materials(new QVector<Material>)
{ {
//open file //open file
m_file.open(path.toStdString().c_str(), std::ios::in | std::ios::binary); m_file.setFileName(path);
if (!m_file.is_open()) if (!m_file.open(QIODevice::ReadOnly))
throw std::invalid_argument(std::string("ERROR: file not found: ") += path.toStdString()); throw std::invalid_argument(std::string("ERROR: file not found: ") += path.toStdString());
m_filepath = path.left(path.lastIndexOf(QRegExp("/|\\\\"))); m_filepath = path.left(path.lastIndexOf(QRegExp("/|\\\\")));
@ -94,7 +94,7 @@ public:
protected: protected:
QVector<Model*>* m_models; QVector<Model*>* m_models;
std::fstream m_file; QFile m_file;
QVector<Material>* m_materials; QVector<Material>* m_materials;
BoundingBox m_sceneBbox; BoundingBox m_sceneBbox;
QString m_filepath; QString m_filepath;

30
QtMeshViewer/Header/MshFile.h
View File

@ -1,11 +1,11 @@
#pragma once #pragma once
#include "..\Header\FileInterface.h" #include "..\Header\FileInterface.h"
#include <QList>
struct ChunkHeader { struct ChunkHeader {
char name[5]; QString name;
std::uint32_t size; quint32 size;
std::streampos position; qint64 position;
}; };
enum ModelTyp { enum ModelTyp {
@ -29,22 +29,22 @@ private:
virtual void import() Q_DECL_OVERRIDE Q_DECL_FINAL; virtual void import() Q_DECL_OVERRIDE Q_DECL_FINAL;
void loadChunks(std::list<ChunkHeader*> &destination, std::streampos start, const std::uint32_t length); void loadChunks(QList<ChunkHeader*> &destination, qint64 start, const quint32 length);
void analyseMsh2Chunks(std::list<ChunkHeader*> &chunkList); void analyseMsh2Chunks(QList<ChunkHeader*> &chunkList);
void analyseMatdChunks(std::list<ChunkHeader*> &chunkList); void analyseMatdChunks(QList<ChunkHeader*> &chunkList);
void analyseModlChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList); void analyseModlChunks(Model* dataDestination, QList<ChunkHeader*> &chunkList);
void analyseGeomChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList); void analyseGeomChunks(Model* dataDestination, QList<ChunkHeader*> &chunkList);
void analyseSegmChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList); void analyseSegmChunks(Model* dataDestination, QList<ChunkHeader*> &chunkList);
void analyseClthChunks(Model* dataDestination, std::list<ChunkHeader*> &chunkList); void analyseClthChunks(Model* dataDestination, QList<ChunkHeader*> &chunkList);
void readVertex(Segment* dataDestination, std::streampos position); void readVertex(Segment* dataDestination, qint64 position);
void readUV(Segment* dataDestination, std::streampos position); void readUV(Segment* dataDestination, qint64 position);
void loadTexture(QOpenGLTexture*& destination, QString filepath, QString& filename); void loadTexture(QOpenGLTexture*& destination, QString filepath, QString& filename);
QMatrix4x4 getParentMatrix(std::string parent) const; QMatrix4x4 getParentMatrix(QString parent) const;
QQuaternion getParentRotation(std::string parent) const; QQuaternion getParentRotation(QString parent) const;
}; };

4
QtMeshViewer/Source/GeometryEngine.cpp
View File

@ -5,6 +5,7 @@
#include "..\Header\OutputDevice.h" #include "..\Header\OutputDevice.h"
#include <QRegExp> #include <QRegExp>
#include "..\Header\Profiler.h"
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// constructor/destructor // constructor/destructor
@ -140,6 +141,7 @@ void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
void GeometryEngine::loadFile(QString filePath) void GeometryEngine::loadFile(QString filePath)
{ {
TIC("Start");
// cleanup old stuff and recreate buffers // cleanup old stuff and recreate buffers
clearData(); clearData();
m_arrayBuf.create(); m_arrayBuf.create();
@ -214,5 +216,7 @@ void GeometryEngine::loadFile(QString filePath)
clearData(); clearData();
OutputDevice::getInstance()->print(QString(e.what()), 2); OutputDevice::getInstance()->print(QString(e.what()), 2);
} }
TOC("End");
} }

215
QtMeshViewer/Source/MshFile.cpp
View File

@ -1,7 +1,6 @@
#include "..\Header\MshFile.h" #include "..\Header\MshFile.h"
#include "..\Header\tga.h" #include "..\Header\tga.h"
#include "..\Header\OutputDevice.h" #include "..\Header\OutputDevice.h"
#include <QColor>
// helper function to save data from file to any variable type // helper function to save data from file to any variable type
@ -28,22 +27,22 @@ MshFile::~MshFile()
void MshFile::import() void MshFile::import()
{ {
// go to file size information // go to file size information
m_file.seekg(4); m_file.seek(4);
std::uint32_t tmp_fileSize; quint32 tmp_fileSize;
std::list<ChunkHeader*> tmp_mainChunks; QList<ChunkHeader*> tmp_mainChunks;
// get all chunks under HEDR // get all chunks under HEDR
m_file.read(F2V(tmp_fileSize), sizeof(tmp_fileSize)); m_file.read(F2V(tmp_fileSize), sizeof(tmp_fileSize));
loadChunks(tmp_mainChunks, m_file.tellg(), tmp_fileSize); loadChunks(tmp_mainChunks, m_file.pos(), tmp_fileSize);
// evaulate HEDR subchunks (= find MSH2) // evaulate HEDR subchunks (= find MSH2)
for (ChunkHeader* it : tmp_mainChunks) for (ChunkHeader* it : tmp_mainChunks)
{ {
if (!strcmp("MSH2", it->name)) if ("MSH2" == it->name)
{ {
// get all subchunks // get all subchunks
std::list<ChunkHeader*> tmp_msh2Chunks; QList<ChunkHeader*> tmp_msh2Chunks;
loadChunks(tmp_msh2Chunks, it->position, it->size); loadChunks(tmp_msh2Chunks, it->position, it->size);
// evaluate MSH2 subchunks // evaluate MSH2 subchunks
@ -68,54 +67,62 @@ void MshFile::import()
} }
} }
void MshFile::loadChunks(std::list<ChunkHeader*>& destination, std::streampos start, const std::uint32_t length) void MshFile::loadChunks(QList<ChunkHeader*>& destination, qint64 start, const quint32 length)
{ {
// jump to first chunk // jump to first chunk
m_file.seekg(start); m_file.seek(start);
do do
{ {
ChunkHeader* tmp_header = new ChunkHeader(); ChunkHeader* tmp_header = new ChunkHeader();
char workaround[5] = { 0 };
// get information // get information
m_file.read(F2V(tmp_header->name[0]), sizeof(tmp_header->name) - 1); m_file.read(F2V(workaround[0]), sizeof(workaround) -1);
tmp_header->name = QString(workaround);
m_file.read(F2V(tmp_header->size), sizeof(tmp_header->size)); m_file.read(F2V(tmp_header->size), sizeof(tmp_header->size));
tmp_header->position = m_file.tellg(); tmp_header->position = m_file.pos();
// store information // store information
destination.push_back(tmp_header); destination.push_back(tmp_header);
// jump to next header // jump to next header
m_file.seekg(tmp_header->size, std::ios_base::cur); if (!m_file.seek(tmp_header->size + m_file.pos()))
// out of file. Maybe a size information is corrupted
if (!m_file.good())
{ {
OutputDevice::getInstance()->print("WARNING: corrupted file. Trying to continue..", 1); OutputDevice::getInstance()->print("WARNING: corrupted file. Trying to continue..", 1);
m_file.clear(); m_file.unsetError();
m_file.seek(0);
break; break;
} }
} while (m_file.tellg() - start != length); // out of file. Maybe a size information is corrupted
if (m_file.error() != QFileDevice::NoError)
{
OutputDevice::getInstance()->print("WARNING: corrupted file. Trying to continue..", 1);
m_file.unsetError();
m_file.seek(0);
break;
}
} while (m_file.pos() - start != length);
} }
void MshFile::analyseMsh2Chunks(std::list<ChunkHeader*>& chunkList) void MshFile::analyseMsh2Chunks(QList<ChunkHeader*>& chunkList)
{ {
for (auto& it : chunkList) for (auto& it : chunkList)
{ {
// scene information // scene information
if (!strcmp("SINF", it->name)) if ("SINF" == it->name)
{ {
// get SINF subchunks // get SINF subchunks
std::list<ChunkHeader*> tmp_sinfChunks; QList<ChunkHeader*> tmp_sinfChunks;
loadChunks(tmp_sinfChunks, it->position, it->size); loadChunks(tmp_sinfChunks, it->position, it->size);
// evaluate SINF subchunks // evaluate SINF subchunks
for (auto& it : tmp_sinfChunks) for (auto& it : tmp_sinfChunks)
{ {
if (!strcmp("BBOX", it->name)) if ("BBOX" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
// read in the quaternion // read in the quaternion
float tmp_quat[4]; float tmp_quat[4];
@ -143,24 +150,25 @@ void MshFile::analyseMsh2Chunks(std::list<ChunkHeader*>& chunkList)
} }
// material list // material list
else if (!strcmp("MATL", it->name)) else if ("MATL" == it->name)
{ {
OutputDevice::getInstance()->print("loading materials..", 0);
// "useless" information how many MATD follow, jump over it // "useless" information how many MATD follow, jump over it
m_file.seekg(it->position); m_file.seek(it->position);
m_file.seekg(sizeof(std::uint32_t), std::ios_base::cur); m_file.seek(sizeof(quint32) + m_file.pos());
// get all MATL subchunk // get all MATL subchunk
std::list<ChunkHeader*> tmp_matlChunks; QList<ChunkHeader*> tmp_matlChunks;
loadChunks(tmp_matlChunks, m_file.tellg(), it->size - 4); loadChunks(tmp_matlChunks, m_file.pos(), it->size - 4);
// evaluate MATL subchunks // evaluate MATL subchunks
for (auto& it : tmp_matlChunks) for (auto& it : tmp_matlChunks)
{ {
// This shouldn't be anything else than MATD // This shouldn't be anything else than MATD
if (!strcmp("MATD", it->name)) if ("MATD" == it->name)
{ {
// get all subchunks from MATD // get all subchunks from MATD
std::list<ChunkHeader*> tmp_matdChunks; QList<ChunkHeader*> tmp_matdChunks;
loadChunks(tmp_matdChunks, it->position, it->size); loadChunks(tmp_matdChunks, it->position, it->size);
m_materials->push_back(Material()); m_materials->push_back(Material());
@ -188,14 +196,15 @@ void MshFile::analyseMsh2Chunks(std::list<ChunkHeader*>& chunkList)
} }
// model // model
else if (!strcmp("MODL", it->name)) else if ("MODL" == it->name)
{ {
OutputDevice::getInstance()->print("loading model..", 0);
Model* new_model = new Model; Model* new_model = new Model;
m_currentType = ModelTyp::null; m_currentType = ModelTyp::null;
m_currentRenderFlag = -1; m_currentRenderFlag = -1;
// get all MODL subchunks // get all MODL subchunks
std::list<ChunkHeader*> tmp_chunks; QList<ChunkHeader*> tmp_chunks;
loadChunks(tmp_chunks, it->position, it->size); loadChunks(tmp_chunks, it->position, it->size);
// evaluate MODL subchunks // evaluate MODL subchunks
@ -215,14 +224,14 @@ void MshFile::analyseMsh2Chunks(std::list<ChunkHeader*>& chunkList)
} }
} }
void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList) void MshFile::analyseMatdChunks(QList<ChunkHeader*>& chunkList)
{ {
for (auto& it : chunkList) for (auto& it : chunkList)
{ {
// name // name
if (!strcmp("NAME", it->name)) if ("NAME" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -231,9 +240,9 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
} }
// data // data
else if(!strcmp("DATA", it->name)) else if("DATA" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
// diffuse // diffuse
for (unsigned int i = 0; i < 4; i++) for (unsigned int i = 0; i < 4; i++)
@ -252,18 +261,18 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
} }
// attributes // attributes
else if (!strcmp("ATRB", it->name)) else if ("ATRB" == it->name)
{ {
// get pointer to current material // get pointer to current material
Material* curMat = &m_materials->back(); Material* curMat = &m_materials->back();
// read the attributes // read the attributes
m_file.seekg(it->position); m_file.seek(it->position);
std::uint8_t flag; quint8 flag;
m_file.read(F2V(flag), sizeof(flag)); m_file.read(F2V(flag), sizeof(flag));
m_file.read(F2V(curMat->rendertype), sizeof(std::uint8_t)); m_file.read(F2V(curMat->rendertype), sizeof(quint8));
m_file.read(F2V(curMat->dataValues[0]), sizeof(std::uint8_t)); m_file.read(F2V(curMat->dataValues[0]), sizeof(quint8));
m_file.read(F2V(curMat->dataValues[1]), sizeof(std::uint8_t)); m_file.read(F2V(curMat->dataValues[1]), sizeof(quint8));
// flags // flags
// 0: emissive // 0: emissive
@ -276,16 +285,16 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
// 7: specular // 7: specular
for (unsigned int i = 0; i < 8; i++) for (unsigned int i = 0; i < 8; i++)
curMat->flags[i] = (std::uint8_t)(flag << (7 - i)) >> 7; curMat->flags[i] = (quint8)(flag << (7 - i)) >> 7;
curMat->transparent = curMat->flags[2] || curMat->flags[3] || curMat->flags[4] || curMat->flags[6] || curMat->rendertype == 4; curMat->transparent = curMat->flags[2] || curMat->flags[3] || curMat->flags[4] || curMat->flags[6] || curMat->rendertype == 4;
} }
// texture 0 // texture 0
else if (!strcmp("TX0D", it->name)) else if ("TX0D" == it->name)
{ {
// get the texture name // get the texture name
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -298,10 +307,10 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
} }
// texture 1 // texture 1
else if (!strcmp("TX1D", it->name)) else if ("TX1D" == it->name)
{ {
// get the texture name // get the texture name
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -313,10 +322,10 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
} }
// texture 2 // texture 2
else if (!strcmp("TX2D", it->name)) else if ("TX2D" == it->name)
{ {
// get the texture name // get the texture name
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -325,10 +334,10 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
} }
// texture 3 // texture 3
else if (!strcmp("TX3D", it->name)) else if ("TX3D" == it->name)
{ {
// get the texture name // get the texture name
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -338,23 +347,23 @@ void MshFile::analyseMatdChunks(std::list<ChunkHeader*>& chunkList)
} }
} }
void MshFile::analyseModlChunks(Model * dataDestination, std::list<ChunkHeader*>& chunkList) void MshFile::analyseModlChunks(Model * dataDestination, QList<ChunkHeader*>& chunkList)
{ {
for (auto& it : chunkList) for (auto& it : chunkList)
{ {
// model type // model type
if (!strcmp("MTYP", it->name)) if ("MTYP" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
std::uint32_t tmp_type; quint32 tmp_type;
m_file.read(F2V(tmp_type), sizeof(tmp_type)); m_file.read(F2V(tmp_type), sizeof(tmp_type));
m_currentType = (ModelTyp)tmp_type; m_currentType = (ModelTyp)tmp_type;
} }
// parent name // parent name
else if (!strcmp("PRNT", it->name)) else if ("PRNT" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -363,9 +372,9 @@ void MshFile::analyseModlChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
// model name // model name
else if (!strcmp("NAME", it->name)) else if ("NAME" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -374,20 +383,20 @@ void MshFile::analyseModlChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
// render flags // render flags
else if (!strcmp("FLGS", it->name)) else if ("FLGS" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
m_file.read(F2V(m_currentRenderFlag), sizeof(m_currentRenderFlag)); m_file.read(F2V(m_currentRenderFlag), sizeof(m_currentRenderFlag));
} }
// translation // translation
else if (!strcmp("TRAN", it->name)) else if ("TRAN" == it->name)
{ {
float tmp_scale[3]; float tmp_scale[3];
float tmp_rotation[4]; float tmp_rotation[4];
float tmp_trans[3]; float tmp_trans[3];
m_file.seekg(it->position); m_file.seek(it->position);
// read in the data // read in the data
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
@ -410,14 +419,14 @@ void MshFile::analyseModlChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
// geometry data // geometry data
else if (!strcmp("GEOM", it->name)) else if ("GEOM" == it->name)
{ {
// don't get null, bone, shadowMesh and hidden mesh indices // don't get null, bone, shadowMesh and hidden mesh indices
if (m_currentType == null || m_currentType == bone || m_currentType == shadowMesh || m_currentRenderFlag == 1) if (m_currentType == null || m_currentType == bone || m_currentType == shadowMesh || m_currentRenderFlag == 1)
continue; continue;
// get all GEOM subchunks // get all GEOM subchunks
std::list<ChunkHeader*> tmp_geomChunks; QList<ChunkHeader*> tmp_geomChunks;
loadChunks(tmp_geomChunks, it->position, it->size); loadChunks(tmp_geomChunks, it->position, it->size);
// evaluate GEOM subchunks // evaluate GEOM subchunks
@ -434,15 +443,15 @@ void MshFile::analyseModlChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
} }
void MshFile::analyseGeomChunks(Model * dataDestination, std::list<ChunkHeader*>& chunkList) void MshFile::analyseGeomChunks(Model * dataDestination, QList<ChunkHeader*>& chunkList)
{ {
for (auto& it : chunkList) for (auto& it : chunkList)
{ {
// segment // segment
if (!strcmp("SEGM", it->name)) if ("SEGM" == it->name)
{ {
// get all SEGM subchunks // get all SEGM subchunks
std::list<ChunkHeader*> tmp_segmChunks; QList<ChunkHeader*> tmp_segmChunks;
loadChunks(tmp_segmChunks, it->position, it->size); loadChunks(tmp_segmChunks, it->position, it->size);
// evaluate SEGM subchunks // evaluate SEGM subchunks
@ -458,10 +467,10 @@ void MshFile::analyseGeomChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
// cloth // cloth
else if (!strcmp("CLTH", it->name)) else if ("CLTH" == it->name)
{ {
// get all CLTH subchunks // get all CLTH subchunks
std::list<ChunkHeader*> tmp_clthChunks; QList<ChunkHeader*> tmp_clthChunks;
loadChunks(tmp_clthChunks, it->position, it->size); loadChunks(tmp_clthChunks, it->position, it->size);
// evaluate CLTH subchunks // evaluate CLTH subchunks
@ -478,30 +487,30 @@ void MshFile::analyseGeomChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
} }
void MshFile::analyseSegmChunks(Model * dataDestination, std::list<ChunkHeader*>& chunkList) void MshFile::analyseSegmChunks(Model * dataDestination, QList<ChunkHeader*>& chunkList)
{ {
Segment* new_segment = new Segment; Segment* new_segment = new Segment;
for (auto& it : chunkList) for (auto& it : chunkList)
{ {
// material index // material index
if (!strcmp("MATI", it->name)) if ("MATI" == it->name)
{ {
m_file.seekg(it->position); m_file.seek(it->position);
m_file.read(F2V(new_segment->textureIndex), sizeof(new_segment->textureIndex)); m_file.read(F2V(new_segment->textureIndex), sizeof(new_segment->textureIndex));
} }
// position list (vertex) // position list (vertex)
else if (!strcmp("POSL", it->name)) else if ("POSL" == it->name)
{ {
readVertex(new_segment, it->position); readVertex(new_segment, it->position);
} }
// normals // normals
else if (!strcmp("NRML", it->name)) else if ("NRML" == it->name)
{ {
std::uint32_t tmp_size; quint32 tmp_size;
m_file.seekg(it->position); m_file.seek(it->position);
m_file.read(F2V(tmp_size), sizeof(tmp_size)); m_file.read(F2V(tmp_size), sizeof(tmp_size));
if (tmp_size < (unsigned) new_segment->vertices.size()) if (tmp_size < (unsigned) new_segment->vertices.size())
@ -525,18 +534,18 @@ void MshFile::analyseSegmChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
// uv // uv
else if (!strcmp("UV0L", it->name)) else if ("UV0L" == it->name)
{ {
readUV(new_segment, it->position); readUV(new_segment, it->position);
} }
// polygons (indices into vertex/uv list) // polygons (indices into vertex/uv list)
else if (!strcmp("STRP", it->name)) else if ("STRP" == it->name)
{ {
// jump to the data section and read the size; // jump to the data section and read the size;
std::uint32_t tmp_size; quint32 tmp_size;
m_file.seekg(it->position); m_file.seek(it->position);
m_file.read(F2V(tmp_size), sizeof(tmp_size)); m_file.read(F2V(tmp_size), sizeof(tmp_size));
int highBitCount(0); int highBitCount(0);
@ -545,7 +554,7 @@ void MshFile::analyseSegmChunks(Model * dataDestination, std::list<ChunkHeader*>
for (unsigned int i = 0; i < tmp_size; i++) for (unsigned int i = 0; i < tmp_size; i++)
{ {
// ReadData // ReadData
std::uint16_t tmp_value; quint16 tmp_value;
m_file.read(F2V(tmp_value), sizeof(tmp_value)); m_file.read(F2V(tmp_value), sizeof(tmp_value));
// Check if highbit is set // Check if highbit is set
@ -553,7 +562,7 @@ void MshFile::analyseSegmChunks(Model * dataDestination, std::list<ChunkHeader*>
{ {
highBitCount++; highBitCount++;
// remove the high bit, to get the actually value // remove the high bit, to get the actually value
tmp_value = (std::uint16_t(tmp_value << 1) >> 1); tmp_value = (quint16(tmp_value << 1) >> 1);
} }
// save data // save data
@ -607,17 +616,17 @@ void MshFile::analyseSegmChunks(Model * dataDestination, std::list<ChunkHeader*>
dataDestination->segmList.push_back(new_segment); dataDestination->segmList.push_back(new_segment);
} }
void MshFile::analyseClthChunks(Model * dataDestination, std::list<ChunkHeader*>& chunkList) void MshFile::analyseClthChunks(Model * dataDestination, QList<ChunkHeader*>& chunkList)
{ {
Segment* new_segment = new Segment; Segment* new_segment = new Segment;
for (auto& it : chunkList) for (auto& it : chunkList)
{ {
// texture name // texture name
if (!strcmp("CTEX", it->name)) if ("CTEX" == it->name)
{ {
// read the texture name // read the texture name
m_file.seekg(it->position); m_file.seek(it->position);
char* buffer = new char[it->size + 1]; char* buffer = new char[it->size + 1];
*buffer = { 0 }; *buffer = { 0 };
m_file.read(buffer, it->size); m_file.read(buffer, it->size);
@ -638,30 +647,30 @@ void MshFile::analyseClthChunks(Model * dataDestination, std::list<ChunkHeader*>
} }
// position list (vertex) // position list (vertex)
else if (!strcmp("CPOS", it->name)) else if ("CPOS" == it->name)
{ {
readVertex(new_segment, it->position); readVertex(new_segment, it->position);
} }
// uv // uv
else if (!strcmp("CUV0", it->name)) else if ("CUV0" == it->name)
{ {
readUV(new_segment, it->position); readUV(new_segment, it->position);
} }
// triangles (indices into vertex/uv list) // triangles (indices into vertex/uv list)
else if (!strcmp("CMSH", it->name)) else if ("CMSH" == it->name)
{ {
// jump to the data section and read the size; // jump to the data section and read the size;
std::uint32_t tmp_size; quint32 tmp_size;
m_file.seekg(it->position); m_file.seek(it->position);
m_file.read(F2V(tmp_size), sizeof(tmp_size)); m_file.read(F2V(tmp_size), sizeof(tmp_size));
// for every triangle.. // for every triangle..
for (unsigned int i = 0; i < tmp_size * 3; i++) for (unsigned int i = 0; i < tmp_size * 3; i++)
{ {
std::uint32_t tmp_value; quint32 tmp_value;
m_file.read(F2V(tmp_value), sizeof(std::uint32_t)); m_file.read(F2V(tmp_value), sizeof(quint32));
new_segment->indices.push_back((GLuint)tmp_value); new_segment->indices.push_back((GLuint)tmp_value);
} }
@ -671,10 +680,10 @@ void MshFile::analyseClthChunks(Model * dataDestination, std::list<ChunkHeader*>
dataDestination->segmList.push_back(new_segment); dataDestination->segmList.push_back(new_segment);
} }
void MshFile::readVertex(Segment * dataDestination, std::streampos position) void MshFile::readVertex(Segment * dataDestination, qint64 position)
{ {
std::uint32_t tmp_size; quint32 tmp_size;
m_file.seekg(position); m_file.seek(position);
m_file.read(F2V(tmp_size), sizeof(tmp_size)); m_file.read(F2V(tmp_size), sizeof(tmp_size));
for (unsigned int i = 0; i < tmp_size; i++) for (unsigned int i = 0; i < tmp_size; i++)
@ -690,10 +699,10 @@ void MshFile::readVertex(Segment * dataDestination, std::streampos position)
} }
} }
void MshFile::readUV(Segment * dataDestination, std::streampos position) void MshFile::readUV(Segment * dataDestination, qint64 position)
{ {
std::uint32_t tmp_size; quint32 tmp_size;
m_file.seekg(position); m_file.seek(position);
m_file.read(F2V(tmp_size), sizeof(tmp_size)); m_file.read(F2V(tmp_size), sizeof(tmp_size));
if (tmp_size < (unsigned) dataDestination->vertices.size()) if (tmp_size < (unsigned) dataDestination->vertices.size())
@ -746,13 +755,13 @@ void MshFile::loadTexture(QOpenGLTexture *& destination, QString filepath, QStri
destination = new_texture; destination = new_texture;
} }
QMatrix4x4 MshFile::getParentMatrix(std::string parent) const QMatrix4x4 MshFile::getParentMatrix(QString parent) const
{ {
QMatrix4x4 matrix; QMatrix4x4 matrix;
for (auto& it : *m_models) for (auto& it : *m_models)
{ {
if (!strcmp(parent.c_str(), it->name.c_str())) if (parent == it->name)
{ {
matrix = getParentMatrix(it->parent) * it->m4x4Translation; matrix = getParentMatrix(it->parent) * it->m4x4Translation;
break; break;
@ -762,13 +771,13 @@ QMatrix4x4 MshFile::getParentMatrix(std::string parent) const
return matrix; return matrix;
} }
QQuaternion MshFile::getParentRotation(std::string parent) const QQuaternion MshFile::getParentRotation(QString parent) const
{ {
QQuaternion rotation; QQuaternion rotation;
for (auto& it : *m_models) for (auto& it : *m_models)
{ {
if (!strcmp(parent.c_str(), it->name.c_str())) if (parent == it->name)
{ {
rotation = getParentRotation(it->parent) * it->quadRotation; rotation = getParentRotation(it->parent) * it->quadRotation;
break; break;