Common pitfalls/causes of bad vertex data? - c++

Question

So, I've been working on this .OBJ/.MTL mesh parser for the past week and a half. Within this time I've been tracking down/fixing a lot of bugs, cleaning up code, documenting it, etc etc.
The problem is that, with every bug I fix, there still is this issue which crops up, and since a picture is worth a thousand words...
Using GL_LINE_LOOP
(NOTE: the pyramid on the right tipping outward from the sphere is the problem here)
Using GL_TRIANGLES
What's even more interesting is that this "bad" vertex data appears to move with the camera when floating around the scene...except that it scales and sticks outside of the mesh.
The odd thing here is that while I'm sure the issue has something to do with memory, I've been checking for issues which contradict whether or not the parsing algorithm works properly. After some unit tests, it appears to be working fine.
So, I thought it may be a Linux nVidia driver issue. I updated the driver to the next version, restarted, and still no dice.
After some heavy thinking, I've been trying to find errors in the following code.
//! every 3 vertices should represent a triangle, therefore we'll want to
//! use the indices to grab their corresponding vertices. Since the cross product
//! of two sides of every triangle (where one side = Vn - Vm, 'n' and 'm' being on the range of 1..3),
//! we first grab the three vertices, and then compute the normal using the their differences.
const uInt32 length = mesh->vertices.size();
//! declare a pointer to the vector so we can perform simple
//! memory copies to get the indices for each triangle within the
//! iteration.
GLuint* const pIndexBuf = &mesh->indices[ 0 ];
for ( uInt32 i = 0; i < length; i += 3 )
{
GLuint thisTriIndices[ 3 ];
memcpy( thisTriIndices, pIndexBuf + i, sizeof( GLuint ) * 3 );
vec3 vertexOne = vec3( mesh->vertices[ thisTriIndices[ 0 ] ] );
vec3 vertexTwo = vec3( mesh->vertices[ thisTriIndices[ 1 ] ] );
vec3 vertexThree = vec3( mesh->vertices[ thisTriIndices[ 2 ] ] );
vec3 sideOne = vertexTwo - vertexOne;
vec3 sideTwo = vertexThree - vertexOne;
vec3 surfaceNormal = glm::cross( sideOne, sideTwo );
mesh->normals.push_back( surfaceNormal );
}
The current one shown in the picture doesn't even have normal data, so the idea is to compute surface normals for it, hence the above code. While I've made some checks to see if the index data was being loaded properly within the loop, I haven't been able to find anything yet.
I think the way I'm laying out my memory might have problems too, but I can't quite put my finger on what the problem would be. In case I've missed something, I'll throw in my glVertexAttribPointer calls:
//! Gen some buf handles
glGenBuffers( NUM_BUFFERS_PER_MESH, mesh->buffers );
//! Load the respective buffer data for the mesh
__LoadVec4Buffer( mesh->buffers[ BUFFER_VERTEX ], mesh->vertices ); //! positons
__LoadVec4Buffer( mesh->buffers[ BUFFER_COLOR ], mesh->colors ); //! material colors
__LoadVec3Buffer( mesh->buffers[ BUFFER_NORMAL ], mesh->normals ); //! normals
__LoadIndexBuffer( mesh->buffers[ BUFFER_INDEX ], mesh->indices ); //! indices
//! assign the vertex array a value
glGenVertexArrays( 1, &mesh->vertexArray );
//! Specify the memory layout for each attribute
glBindVertexArray( mesh->vertexArray );
//! Position and color are both stored in BUFFER_VERTEX.
glBindBuffer( GL_ARRAY_BUFFER, mesh->buffers[ BUFFER_VERTEX ] );
glEnableVertexAttribArray( meshProgram->attributes[ "position" ] );
glVertexAttribPointer( meshProgram->attributes[ "position" ], //! index
4, //! num vals
GL_FLOAT, GL_FALSE, //! value type, normalized?
sizeof( vec4 ), //! number of bytes until next value in the buffer
( void* ) 0 ); //! offset of the memory in the buffer
glBindBuffer( GL_ARRAY_BUFFER, mesh->buffers[ BUFFER_COLOR ] );
glEnableVertexAttribArray( meshProgram->attributes[ "color" ] );
glVertexAttribPointer( meshProgram->attributes[ "color" ],
4,
GL_FLOAT, GL_FALSE,
sizeof( vec4 ),
( void* ) 0 );
//! Now we specify the layout for the normals
glBindBuffer( GL_ARRAY_BUFFER, mesh->buffers[ BUFFER_NORMAL ] );
glEnableVertexAttribArray( meshProgram->attributes[ "normal" ] );
glVertexAttribPointer( meshProgram->attributes[ "normal" ],
3,
GL_FLOAT, GL_FALSE,
sizeof( vec3 ),
( void* )0 );
//! Include the index buffer within the vertex array
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->buffers[ BUFFER_INDEX ] );
glBindVertexArray( 0 );
Any kind of point in the right direction at the very least would be appreciated: I have no idea what the common causes are for these issues.
Edit: posted draw code on request
glBindVertexArray( mMeshes[ i ]->vertexArray );
UBO::LoadMatrix4( UBO::MATRIX_MODELVIEW, modelView.top() );
UBO::LoadMatrix4( UBO::MATRIX_PROJECTION, camera.projection() );
glDrawElements( GL_TRIANGLES, mMeshes[ i ]->indices.size(), GL_UNSIGNED_INT, ( void* )0 );
glBindVertexArray( 0 );

Answer 1

I found the final culprit, in conjunction with #radical7's suggestions, these fixed the issue for the most part.
// round mesh->indices.size() down if it's not already divisible by 3.
// the rounded value is stored in numTris
std::vector< vec4 > newVertices;
uInt32 indicesLen = Math_FloorForMultiple( mesh->indices.size(), 3 );
// declare a pointer to the vector so we can perform simple
// memory copies to get the indices for each triangle within the
// iteration.
newVertices.reserve( indicesLen );
const GLuint* const pIndexBuf = &mesh->indices[ 0 ];
for ( uInt32 i = 0; i < indicesLen; i += 3 )
{
const GLuint* const thisTriIndices = pIndexBuf + i;
vec4 vertexOne = mesh->vertices[ thisTriIndices[ 0 ] - 1 ];
vec4 vertexTwo = mesh->vertices[ thisTriIndices[ 1 ] - 1 ];
vec4 vertexThree = mesh->vertices[ thisTriIndices[ 2 ] - 1 ];
vec4 sideOne = vertexTwo - vertexOne;
vec4 sideTwo = vertexThree - vertexOne;
vec3 surfaceNormal = glm::cross( vec3( sideOne ), vec3( sideTwo ) );
mesh->normals.push_back( surfaceNormal );
mesh->normals.push_back( surfaceNormal + vec3( sideOne ) );
mesh->normals.push_back( surfaceNormal + vec3( sideTwo ) );
newVertices.push_back( vertexOne );
newVertices.push_back( vertexTwo );
newVertices.push_back( vertexThree );
}
mesh->vertices.clear();
mesh->vertices = newVertices;
Note that when the vertices are grabbed in the loop, via the call to mesh->vertices[ thisTriIndices[ x ] - 1 ], the - 1 is extremely important: OBJ mesh files store their face indices starting from 1...N indices, as opposed to 0....N-1 indices.
The indices themselves also shouldn't be used to draw the mesh, but rather as a means to obtain a new buffer of vertices from an already temporary buffer of vertices: you use the indices to access the elements within the temporary vertices, and then for each vertex obtained from the temp buffer, you add that vertex to a new buffer. This way, you'll get the number of vertices specified in the correct draw order. Thus, you want to draw them using vertex arrays only.