C++ OpenGL Flickering on Large Element Count Draw - c++

Question

Currently working on a personal implementation of the Boids Flocking simulation to test what I've learned about OpenGL, I've been looking to see how high I can get the # of bonds drawn upon the screen above 30 FPS.
Unfortunately I've hit a road-block with how at 2^16 and beyond boids (Where each boid is three float vertices each of size 3, where the z value is maintained to be 0) the graphical output begins to flicker with boids disappearing and reappearing upon the screen.
Interestingly this only seems to happens in the beginning stages of the app, with the flickering seemingly ending upon the boids forming their "flocks" and coincidentally clumping together visually.
I am also suspect of the number 2^16 as it matches with the GLshort bit count of 16, so potentially an overflow of the values?
Here is the area I thought was most pertinent to the issue
std::vector<float> vertices(flock.boids.size()*9, 0.f);
unsigned int VAO, VBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0])*static_cast<uint>(vertices.size()), vertices.data(), GL_DYNAMIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
float FPS_sum = 0;
size_t frames = 0;
float CPS_sum = 0;
std::chrono::high_resolution_clock::time_point start;
// render loop
while(!glfwWindowShouldClose(window))
{
processInput(window);
//Begin CPS timer
start = std::chrono::high_resolution_clock::now();
//Computation Step
std::vector<point_bucket<Boid> > tree;
point_bucket<Boid> base(0, 0, 2, 2, flock.boids);
base_split(base, 16, tree, 20);
for(auto& elm: tree)
{
flock.Update(elm.bucket);
}
flock.Mirror();
CPS_sum+=1000.f/std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now()-start).count();
// rendering commands here
glClearColor(0.2f, 0.3f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shaderProgram);
//Begin FPS timer
start = std::chrono::high_resolution_clock::now();
glBindVertexArray(VAO);
updateVertices(flock.boids, window, vertices);
updateBuffer(VBO, 0, vertices.data(), sizeof(vertices[0])*static_cast<uint>(vertices.size()), GL_ARRAY_BUFFER);
size_t draw_running_total = vertices.size()/3;
GLint draw_offset = 0;
while(draw_running_total > 0)
{
glDrawArrays(GL_TRIANGLES, draw_offset, draw_running_total > draw_size? draw_size: draw_running_total);
draw_running_total -= draw_size;
draw_offset += draw_size;
}
// check and call events and swap the buffers
glfwSwapBuffers(window);
glfwPollEvents();
// PULL FPS FOR DRAW
FPS_sum+=1000.f/std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now()-start).count();
frames++;
if(frames==100)
{
std::cout << "Average across 100 frames... \n" << FPS_sum/frames << " FPS\n"
<< CPS_sum/frames << " CPS\n";
FPS_sum = 0;
CPS_sum = 0;
frames = 0;
}
//END PULL FOR FPS
}
void updateBuffer(uint &id, uint offset, void *data, uint size, GLenum shaderType)
{
glBindBuffer(shaderType, id);
glBufferSubData(shaderType, offset, size, data);
}
Personally looking online myself I was able to find questions like...
https://stackoverflow.com/questions/24099139/c-opengl-flickering-issues
... which seem only to deal with extraneous buffer swapping, whereas I only swap buffers at the end of the draw loop.
A reddit post addressed a similar issue and found a potential solution in a FBO, but still couldn't discover the root cause of the problem
Any help on would be greatly appreciated!
The GitHub repo for this project is also available for those interested.