Rendering multiple meshes (same VBO) + all indices in same EBO (OpenGL) - c++

Question

I'm trying to minimize memory fragmentation on the GPU by storing all vertex data in the same VBO.
After parsing the .obj nodes with Assimp and extracting all the mesh data, I've alloc'd two large buffers that can contain everything and dumped everything in them (one vertex array and another indices array). Rendering all the data works fine with glDrawArrays, but this is not the result I'm trying to obtain.
struct vertex_data
{
glm::vec3 Position;
glm::vec3 Normal;
glm::vec2 TexCoords;
};
uint32_t TotalVertices = 0;
uint32_t TotalIndices = 0;
uint32_t TotalMeshes = Model->NextMeshToLoad;
if (TotalMeshes != 0)
{
for (uint32_t MeshOffset = 0;
MeshOffset < TotalMeshes;
++MeshOffset)
{
mesh *Mesh = Model->Meshes + MeshOffset;
uint32_t MeshTotalVertices = Mesh->NextVertexData;
uint32_t MeshTotalIndices = Mesh->NextIndice;
TotalVertices += MeshTotalVertices;
TotalIndices += MeshTotalIndices;
}
vertex_data *CombinedVertexData = PushArray(Arena, TotalVertices, vertex_data);
uint32_t *CombinedIndices = PushArray(Arena, TotalIndices, uint32_t);
uint32_t CombinedVertexDataOffset = 0;
uint32_t CombinedIndicesOffset = 0;
for (uint32_t MeshOffset = 0;
MeshOffset < TotalMeshes;
++MeshOffset)
{
mesh *Mesh = Model->Meshes + MeshOffset;
uint32_t MeshTotalVertices = Mesh->NextVertexData;
memcpy_s(CombinedVertexData + CombinedVertexDataOffset, TotalVertices * sizeof(vertex_data),
Mesh->VertexData, MeshTotalVertices * sizeof(vertex_data));
CombinedVertexDataOffset += MeshTotalVertices;
uint32_t MeshTotalIndices = Mesh->NextIndice;
memcpy_s(CombinedIndices + CombinedIndicesOffset, TotalIndices * sizeof(uint32_t),
Mesh->Indices, MeshTotalIndices * sizeof(uint32_t));
CombinedIndicesOffset += MeshTotalIndices;
}
Model->CombinedVertexData = CombinedVertexData;
Model->CombinedIndicesData = CombinedIndices;
Model->CombinedVertexDataSize = TotalVertices;
Model->CombinedIndicesDataSize = TotalIndices;
Model->DataStatus = model_data_status::PENDING_UPLOAD;
Model->NextMeshToLoad stores the next empty array location in which it can store a mesh. It also represents the current size of stored meshes - not to be confounded with the maximum size alloc'd for the array.
Mesh->NextVertexData and Mesh->NextIndice work the same, but for each mesh in part.
Uploading the data to the GPU:
if (Model->DataStatus == model_data_status::PENDING_UPLOAD)
{
glGenVertexArrays(1, &Model->VertexArrayObject);
glGenBuffers(1, &Model->VertexBufferObject);
glGenBuffers(1, &Model->ElementBufferObject);
glBindVertexArray(Model->VertexArrayObject);
glBindBuffer(GL_ARRAY_BUFFER, Model->VertexBufferObject);
glBufferData(GL_ARRAY_BUFFER, Model->CombinedVertexDataSize * sizeof(vertex_data), Model->CombinedVertexData, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, Model->ElementBufferObject);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, Model->CombinedIndicesDataSize * sizeof(uint32_t), &Model->CombinedIndicesData[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vertex_data), 0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vertex_data), (void *)(sizeof(glm::vec3)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(vertex_data), (void *)(2 * sizeof(glm::vec3)));
glBindVertexArray(0);
}
The problem is that each mesh has a different/separate material. This forces me to issue separate draw calls for each mesh (need to set different uniform properties + bind different textures). I know the vertex and indices size for each mesh in part, so I figured I could just call glDrawElements and use the 4th parameter as an offset into the ELEMENT_ARRAY_BUFFER:
glBindVertexArray(Model->VertexArrayObject);
uint32_t IndicesOffset = 0;
uint32_t MeshesSize = Model->NextMeshToLoad;
for (uint32_t MeshIndex = 0;
MeshIndex < MeshesSize;
++MeshIndex)
{
mesh *Mesh = Model->Meshes + MeshIndex;
uint32_t IndicesDataSize = Mesh->NextIndice;
glDrawElements(GL_TRIANGLES, IndicesDataSize, GL_UNSIGNED_INT, (void *)(IndicesOffset * sizeof(uint32_t)));
IndicesOffset += Mesh->NextIndice;
}
glBindVertexArray(0);
Unfortunately this doesn't seem to work... My data is only partially rendered and I can't understand why this is happening. I've checked the data loaded from the .obj file and it's fine. I've also checked the combined vertex data & the combined indices data... it's all there. But my meshes aren't all there on the screen :( (I've enabled wireframe mode so I can better visualize the issue)
If I try to call glDrawArrays on the combined vertex data, it's all working fine and dandy:
At this moment, both the combined vertex and indices arrays register a size of 57174 elements each. Is it not possible for OpenGL to properly map the indices offset to the vertices data internally and properly render? If I use one VBO + EBO per mesh, everything renders fine, so I know the data I'm receiving is not corrupted (further evidenced by glDrawArrays on the combined vertex data). I've been reading and trying all sorts of solutions without anything working... Pretty much at my wits end. Would really appreciate some help! Thanks!