Skip to content
Snippets Groups Projects
Select Git revision
  • ee8705f9e4ecebc1b5a204937aa236d4478df1cb
  • master default protected
  • developement_1 protected
  • Version_1.2.4
  • Version_1.2.3
  • Version_1.2.2
  • Version_1.2.1
  • Version_1.2.0
  • Version_1.0.1
  • Version_1.0.0
  • Version_0.1.0
  • Version_0.0.6
  • Version_0.0.5
  • Version_0.0.4
  • Version_0.0.3
  • Version_0.0.2
  • Version_0.0.1
17 results

GeometryEngine.cpp

  • user avatar
    Anakin authored
    window cosmetic,
    next:
    texture,
    calculate modelmatrix from parent
    ee8705f9
    History
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    GeometryEngine.cpp 4.05 KiB
    #include "..\Header\GeometryEngine.h"
    #include "..\Header\MshFile.h"
    
    
    /////////////////////////////////////////////////////////////////////////
    // public constructor/destructor
    
    GeometryEngine::GeometryEngine()
    	: m_indexBuf(QOpenGLBuffer::IndexBuffer)
    {
    	initializeOpenGLFunctions();
    
    	// Generate 2 VBOs
    	m_arrayBuf.create();
    	m_indexBuf.create();
    
    	// Initializes cube geometry and transfers it to VBOs
    	initCubeGeometry();
    }
    
    GeometryEngine::~GeometryEngine()
    {
    	m_arrayBuf.destroy();
    	m_indexBuf.destroy();
    
    	for (auto it : m_textures)
    		delete it;
    	m_textures.clear();
    	m_textures.squeeze();
    }
    
    
    /////////////////////////////////////////////////////////////////////////
    // private functions
    
    void GeometryEngine::initCubeGeometry()
    {
    	QVector<Model*>* models;
    	QVector<VertexData> vertexData;
    	QVector<GLuint> indexData;
    
    	try
    	{
    		MshFile file("..\\Release\\Msh\\sphere.msh");
    		 models = file.getModels();
    		//TODO use models local, apply MVP directly to the vertex, save size and tex index info
    
    		//TODO: handle the textures
    	}
    	catch (std::invalid_argument e)
    	{
    		//TODO: make a cool message box
    		auto msg = e.what();
    	}
    
    	// collect data
    	unsigned int offsetCount(0);
    	for (auto& modelIterator : *models)
    	{
    		for (auto& segmentIterator : modelIterator->segmList)
    		{
    			// get draw information
    			DrawInformation new_info;
    			new_info.offset = offsetCount;
    			new_info.size = segmentIterator->indices.size();
    			new_info.textureIndex = segmentIterator->textureIndex;
    			new_info.modelMatrix = modelIterator->m4x4Translation;
    
    			// add offset to indices
    			for (auto& it : segmentIterator->indices)
    				it += new_info.offset;
    
    			// save data
    			vertexData += segmentIterator->vertices;
    			indexData += segmentIterator->indices;
    			m_drawList.push_back(new_info);
    
    			// update offset
    			offsetCount += new_info.size;
    		}
    	}
    
    	// 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));
    
    	// load the texture
    	initTexture();
    }
    
    void GeometryEngine::initTexture()
    {
    	// Load cube.png image
    	QOpenGLTexture* new_texture = new QOpenGLTexture(QImage(":images/cube.png").mirrored());
    
    	// Set nearest filtering mode for texture minification
    	new_texture->setMinificationFilter(QOpenGLTexture::Nearest);
    
    	// Set bilinear filtering mode for texture magnification
    	new_texture->setMagnificationFilter(QOpenGLTexture::Linear);
    
    	// Wrap texture coordinates by repeating
    	// f.ex. texture coordinate (1.1, 1.2) is same as (0.1, 0.2)
    	new_texture->setWrapMode(QOpenGLTexture::Repeat);
    
    	m_textures.push_back(new_texture);
    }
    
    
    /////////////////////////////////////////////////////////////////////////
    // public functions
    
    void GeometryEngine::drawGeometry(QOpenGLShaderProgram *program)
    {
    // Setup
    	// Tell OpenGL which VBOs to use
    	m_arrayBuf.bind();
    	m_indexBuf.bind();
    
    	// Allways use texture unit 0
    	program->setUniformValue("texture", 0);
    
    	// Offset for position
    	quintptr offset = 0;
    
    	// 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));
    
    	// Offset for texture coordinate
    	offset += sizeof(QVector3D);
    
    	// 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.last()->bind();
    		else
    			m_textures.at(it.textureIndex)->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)));
    	}
    }