Auto-generated vertex buffer and index buffer not working - c++

Question

In short, I created a function in c++ to create a vertex buffer array and an index buffer array for me based on a vector of vertexes i.e. if you enter 4 points in the vector of vertexes the function should in theory return 2 arrays to be used in the vertex buffer and index buffer. However, this is where the problem arises. After the function returns the arrays, buffers initialised and glDrawElements is called, only one of the 2 (for a square) triangles that make up the square are drawn. I am very confused why.
Here is the code,
Struct defining the stuff the function returns:
struct ResultDataBuffer {
std::vector<float> positions;
std::vector<unsigned int> indices;
unsigned int psize;
unsigned int isize;
unsigned int bpsize;
unsigned int bisize;
};
//positions and indices are the vectors for the buffers (to be converted to arrays)
//psize and isize are the sizes of the vectors
//bpsize and bisize are the byte size of the vectors (i.e. sizeof())
The function itself:
static ResultDataBuffer CalculateBuffers(std::vector<float> vertixes) {
std::vector<float> positions = vertixes;
std::vector<unsigned int> indices;
int length = vertixes.size();
int l = length / 2;
int i = 0;
while (i < l - 2) { //The logic for the index buffer array. If the length of the vertexes is l, this array(vector here) should be 0,1,2 , 0,2,3 ... 0,l-2,l-1
i += 1;
indices.push_back(0);
indices.push_back(i + 1);
indices.push_back(i + 2);
}
return{ vertixes,indices, positions.size(), indices.size(), sizeof(float)*positions.size(), sizeof(unsigned int)*indices.size() };
}
The code in the main function (defenitions of buffers and stuff):
std::vector<float> vertixes = {
-0.5f, -0.5f,
0.5f, -0.5f,
0.5f, 0.5f,
-0.5f, 0.5f,
};
ResultDataBuffer rdb = CalculateBuffers(vertixes);
float* positions = rdb.positions.data(); //Convert vector into array
unsigned int* indices = rdb.indices.data(); //Ditto above
unsigned int buffer;
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, rdb.bpsize, positions, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
unsigned int ibo;
glGenBuffers(1, &ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, rdb.bisize, indices, GL_STATIC_DRAW);
Stuff in the main function (in game loop):
glDrawElements(GL_TRIANGLES, rdb.isize, GL_UNSIGNED_INT, nullptr);
Apologies for the length of this post, I tried to cut it down.
C++ full code: https://pastebin.com/ZGLSQm3b
Shader code (located in /res/shaders/Basic.shader): https://pastebin.com/C1ahVUD9
So to summarize, this code, instead of drawing a square - 2 triangles, draws one triangle only.

Answer 1

The issue is caused by the loop which generates the array of indices:
while (i < l - 2) {
i += 1;
indices.push_back(0);
indices.push_back(i + 1);
indices.push_back(i + 2);
}
This loop generates the indices
0, 2, 3, 0, 3, 4
But you have to generate the indices
0, 1, 2, 0, 2, 3
This is cause, because the control variable is incremented, before the indices are append to the vector.
Increment the control variable at the end of the loop, to solve the issue:
while (i < l - 2) {
indices.push_back(0);
indices.push_back(i + 1);
indices.push_back(i + 2);
i += 1;
}
Or use a for loop:
for (unsigned int i = 0; i < l-2; ++ i)
{
unsigned int t[]{ 0, i+1, i+2 };
indices.insert(indices.end(), t, t+3);
}