SWBF2-Classic-Msh-Viewer/QtMeshViewer/Source/GeometryEngine.cpp

219 lines
5.7 KiB
C++
Raw Normal View History

#include "..\Header\GeometryEngine.h"
#include "..\Header\MshFile.h"
#include "..\Header\OglViewerWidget.h"
#include "..\Header\MainWindow.h"
#include "..\Header\tga.h"
#include <cmath>
2016-12-29 13:06:25 +00:00
/////////////////////////////////////////////////////////////////////////
// public constructor/destructor
GeometryEngine::GeometryEngine(QObject *parent)
: QObject(parent)
, m_indexBuf(QOpenGLBuffer::IndexBuffer)
{
2016-12-29 12:37:15 +00:00
initializeOpenGLFunctions();
}
GeometryEngine::~GeometryEngine()
{
clearData();
}
2016-12-29 13:06:25 +00:00
/////////////////////////////////////////////////////////////////////////
// private functions
void GeometryEngine::loadFile(const char* filePath)
{
// cleanup old stuff and recreate buffers
clearData();
m_arrayBuf.create();
m_indexBuf.create();
//reset view
emit requestResetView();
emit sendMessage("loading file..", 0);
try
{
QVector<Model*>* models;
QVector<std::string>* textureNames;
QVector<VertexData> vertexData;
QVector<GLuint> indexData;
// open file and get the information
MshFile file(filePath, this);
models = file.getModels();
textureNames = file.getTextureNames();
m_boundings = file.getBoundingBox();
2016-12-31 12:04:03 +00:00
// collect data
unsigned int indexOffset(0);
unsigned int vertexOffset(0);
2016-12-31 12:04:03 +00:00
for (auto& modelIterator : *models)
{
for (auto& segmentIterator : modelIterator->segmList)
{
// get draw information
DrawInformation new_info;
new_info.offset = indexOffset;
2016-12-31 12:04:03 +00:00
new_info.size = segmentIterator->indices.size();
new_info.textureIndex = segmentIterator->textureIndex;
new_info.modelMatrix = modelIterator->m4x4Translation;
2017-01-02 15:43:38 +00:00
new_info.modelMatrix.rotate(modelIterator->quadRotation);
2016-12-31 12:04:03 +00:00
// add offset to indices, no need to do it for the first one (maybe it's very big)
if(vertexOffset != 0)
for (auto& it : segmentIterator->indices)
it += vertexOffset;
2016-12-31 12:04:03 +00:00
// save data
vertexData += segmentIterator->vertices;
indexData += segmentIterator->indices;
m_drawList.push_back(new_info);
// update offset
indexOffset += new_info.size;
vertexOffset += segmentIterator->vertices.size();
2016-12-31 12:04:03 +00:00
}
}
// Transfer vertex data to VBO 0
m_arrayBuf.bind();
m_arrayBuf.allocate(vertexData.data(), vertexData.size() * sizeof(VertexData));
// Transfer index data to VBO 1
m_indexBuf.bind();
m_indexBuf.allocate(indexData.data(), indexData.size() * sizeof(GLuint));
// get textures path
std::string path = filePath;
while (path.back() != '/' && path.back() != '\\')
path.pop_back();
emit sendMessage("loading textures..", 0);
// load the textures
for(auto& it : *textureNames)
2017-01-05 12:44:53 +00:00
loadTexture(path.c_str(), it.c_str());
2016-12-31 12:04:03 +00:00
loadTexture("", "");
emit requestUpdate();
emit sendMessage("done..", 0);
}
catch (std::invalid_argument e)
{
2017-01-05 15:18:01 +00:00
clearData();
emit sendMessage(QString(e.what()), 2);
}
}
2017-01-05 12:44:53 +00:00
void GeometryEngine::loadTexture(const char* filePath, const char* fileName)
{
2017-01-05 12:44:53 +00:00
bool loadSuccess(false);
QImage img;
if (!strcmp(fileName, ""))
{
loadSuccess = true;
img = QImage(1, 1, QImage::Format_RGB32);
img.fill(Qt::red);
}
else
2017-01-05 12:44:53 +00:00
img = loadTga((std::string(filePath) + std::string(fileName)).c_str(), loadSuccess);
2017-01-05 15:18:01 +00:00
if (!loadSuccess)
emit sendMessage("WARNING: texture not found or corrupted: " + QString(fileName), 1);
// Load image to OglTexture
QOpenGLTexture* new_texture = new QOpenGLTexture(img.mirrored());
2016-12-29 12:37:15 +00:00
// Set nearest filtering mode for texture minification
2016-12-29 13:06:25 +00:00
new_texture->setMinificationFilter(QOpenGLTexture::Nearest);
2016-12-29 12:37:15 +00:00
// Set bilinear filtering mode for texture magnification
2016-12-29 13:06:25 +00:00
new_texture->setMagnificationFilter(QOpenGLTexture::Linear);
2016-12-29 12:37:15 +00:00
// Wrap texture coordinates by repeating
// f.ex. texture coordinate (1.1, 1.2) is same as (0.1, 0.2)
2016-12-29 13:06:25 +00:00
new_texture->setWrapMode(QOpenGLTexture::Repeat);
m_textures.push_back(new_texture);
2016-12-29 12:37:15 +00:00
}
void GeometryEngine::clearData()
{
if (m_arrayBuf.isCreated())
m_arrayBuf.destroy();
if (m_indexBuf.isCreated())
m_indexBuf.destroy();
for (auto it : m_textures)
delete it;
m_textures.clear();
m_drawList.clear();
}
2016-12-29 13:06:25 +00:00
/////////////////////////////////////////////////////////////////////////
// public functions
2016-12-29 12:37:15 +00:00
void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
{
if (!m_arrayBuf.isCreated() || !m_indexBuf.isCreated())
return;
// Setup
2016-12-29 12:37:15 +00:00
// Tell OpenGL which VBOs to use
2016-12-29 13:06:25 +00:00
m_arrayBuf.bind();
m_indexBuf.bind();
2016-12-29 12:37:15 +00:00
// Allways normalize by this
QMatrix4x4 normMatrix;
float maxExtent = std::max(std::max(m_boundings.extents[0], m_boundings.extents[1]), m_boundings.extents[2]);
normMatrix.scale(1 / maxExtent);
normMatrix.translate(-m_boundings.center[0], -m_boundings.center[1], -m_boundings.center[2]);
program->setUniformValue("norm_matrix", normMatrix);
// Allways use texture unit 0
2016-12-29 12:37:15 +00:00
program->setUniformValue("texture", 0);
2016-12-29 12:37:15 +00:00
// Offset for position
quintptr offset = 0;
2016-12-29 12:37:15 +00:00
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = program->attributeLocation("a_position");
program->enableAttributeArray(vertexLocation);
program->setAttributeBuffer(vertexLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
2016-12-29 12:37:15 +00:00
// Offset for texture coordinate
offset += sizeof(QVector3D);
2016-12-29 12:37:15 +00:00
// Tell OpenGL programmable pipeline how to locate vertex texture coordinate data
int texcoordLocation = program->attributeLocation("a_texcoord");
program->enableAttributeArray(texcoordLocation);
program->setAttributeBuffer(texcoordLocation, GL_FLOAT, offset, 2, sizeof(VertexData));
// Paint
for (auto& it : m_drawList)
{
// bind the correct texture
if (it.textureIndex < m_textures.size())
m_textures.at(it.textureIndex)->bind();
2016-12-31 12:04:03 +00:00
else
m_textures.last()->bind();
// Set model matrix
program->setUniformValue("m_matrix", it.modelMatrix);
// Draw cube geometry using indices from VBO 1
glDrawElements(GL_TRIANGLES, it.size, GL_UNSIGNED_INT, (void*)(it.offset * sizeof(GLuint)));
}
}