OpenGL Drawing Elements for many cube objects [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 5 years ago.
Improve this question
I am building a renderer which takes in many objects and batch renders them to the screen. The full renderer code -> https://github.com/rob-DEV/OpenGL-Model-Viewer/tree/master/OpenGL-Model-Viewer/src/graphics/renderer
Pushing the object (all are cubes containing indexed vertices (8) and 36 indices) to the renderer on each frame call.
//load models
for (int j = 0; j < 5; j++)
{
models.push_back(ObjModel("test-models/box.obj", glm::vec3(i * 5, i, j * 5)));
}
renderer.begin();
for (int i = 0; i < models.size(); i++)
{
//add to render call
renderer.submit(models[i]);
}
renderer.end();
renderer.flush();
render init()
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
glGenVertexArrays(1, &m_VAO);
glGenBuffers(1, &m_VBO);
glBindVertexArray(m_VAO);
glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
glBufferData(GL_ARRAY_BUFFER, RENDERER_BUFFER_SIZE, NULL, GL_STATIC_DRAW);
glEnableVertexAttribArray(SHADER_VERTEX_INDEX);
glEnableVertexAttribArray(SHADER_COLOR_INDEX);
glVertexAttribPointer(SHADER_VERTEX_INDEX, 3, GL_FLOAT, GL_FALSE, RENDERER_VERTEX_SIZE, (const GLvoid*)0);
glVertexAttribPointer(SHADER_COLOR_INDEX, 4, GL_UNSIGNED_BYTE, GL_TRUE, RENDERER_VERTEX_SIZE, (const GLvoid*)(offsetof(VertexData, VertexData::colour)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
//setup element
glGenBuffers(1, &m_IBO);
glBindVertexArray(0);
submission of an object
void Renderer::submit(ObjModel& object)
{
//a vector of vec3 vertices // these are indexed all objects are cubes so 8 verts per object
std::vector<glm::vec3> vertices = object.get_vertices();
std::vector<unsigned int> indices = object.get_indices();
std::vector<unsigned int> colours = object.get_colours();
//adjust the postion and give each picture a random colour & add to buffer
for (unsigned int i = 0; i < vertices.size(); i++)
{
vertices[i] += object.position;
m_VertexBuffer->vertex = vertices[i];
m_VertexBuffer->colour = colours[i];
m_VertexBuffer++;
m_VertexDataCount++;
}
m_IndiceCount += indices.size();
indiceData.insert(indiceData.end(), indices.begin(), indices.end());
}
as you can see i put each vertex (adding the position in the world) and colour in to a simple struct (VertexData*) and I add the indices to a vector.
Here is the actual draw
void Renderer::flush()
{
glBindVertexArray(m_VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_IndiceCount * sizeof(unsigned int), &indiceData[0], GL_STATIC_DRAW);
// Draw the triangles !
glDrawElements(
GL_TRIANGLES, // mode
m_IndiceCount, // count
GL_UNSIGNED_INT, // type
(void*)0 // element array buffer offset
);
indiceData.clear();
m_IndiceCount = 0;
m_VertexDataCount = 0;
}
I realise the length but my question is, why does the position only work for the first cube (either the are drawing on top of each other or only the first cube draws) I can't figure this out. Is there a better way I out of ideas :)

Answer 1

why does the position only work for the first cube (either the are drawing on top of each other or only the first cube draws)
Because you're only drawing these first vertices, just several times:
Pushing the object (all are cubes containing indexed vertices (8) and 36 indices) to the renderer on each frame call.
Every time you call submit, you add those 8 vertices at the end of the vertex array, and you just copy the 36 indices to the end of the index array:
m_IndiceCount += indices.size();
indiceData.insert(indiceData.end(), indices.begin(), indices.end());
For the first cube, the all indices will be in the range 0 to 7, that's fine. But for all following cubes, you also will only use the indices 0 to 7 (because that are the correct indices for the local object alone). However, the second cube's vertices are at index 8 to 15 in the global vertex array. So when you draw the two cubes at once, it will re-draw the first cube just twice.
So the solution should be easy to see: You just need to offset each index in the index array by the actual base offset of the vertices in the global vertex array.