I have a Qt (5.9.1) app that on Windows many of the geometries I'm drawing flickers.  My problem description is vague because I'm at a complete loss.

Does anyone know if there's an issue with flickering on Windows with OpenGL (I think Qt uses [ANGLE](https://chromium.googlesource.com/angle/angle/+/master/README.md) for OpenGL) that would be different than in Linux?  My app on Linux seems to work perfectly.

Specifically, my app draws LIDAR ground points (`GL_POINTS`), and boxes around objects (`GL_LINES`), and range marker circles (`GL_LINE_LOOP`).  These are all drawn to the same context.  I also set up double buffering.  All the rendering takes place on a render thread.  This is done in the style of [Scene Graph - Rendering FBOs in a thread](http://doc.qt.io/qt-5/qtquick-scenegraph-textureinthread-example.html) (so, no Qt3D)

When the app starts, initially it seems fine, but after a couple seconds, different geometries, say, the boxes around objects, and/or the range marker circles, start flickering.  Although they're all on the same context, all of the same geometries (say the range markers) will flicker at the same rate (independent of the other geometry types), or all the boxes.

While this is happening, my measured FPS does slow down, but the flickering still occurs even when the FPS is up at 58+.  <strike>I've even inserted some `glFlush()`es and `glFinish()`es - no impact (either on FPS or flickering.)</strike>  **UPDATE** I must have made a mistake when testing `glFinish()` or something changed, because now `glFinish()` removes the flicking (and kills my FPS.)

The structure of my renderers is that I have one class that sets up the viewports, calls `glClear`, and then invokes `render()` on each renderer.  Those renderers have a buffer setup with vertex array buffers, I set some uniforms, and call `glDrawArrays`.  I don't think I'm doing anything unconventional. e.g.

    opengl_safety_buffer_.bind();

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    QOpenGLVertexArrayObject::Binder vaoBinder(&safety_vao_);
    render_safety_program_->bind();

    glLineWidth(safety_ranges_config_["lineWidth"].value<GLfloat>());
    render_safety_program_->setUniformValue("col", vcol_);

    glUniformMatrix4fv(render_safety_program_->uniformLocation("mvp"), static_cast<GLsizei>(mvp_matrices_.size()), GL_TRUE, reinterpret_cast<GLfloat*>(&(mvp_matrices_[0])));
    glDrawArrays(GL_LINE_LOOP, 0, opengl_safety_buffer_.CountVertices());

    glDisable(GL_BLEND);

    render_safety_program_->release();
    opengl_safety_buffer_.release();

My vertex and fragment shaders are very simple.

I don't have great profiling data right now, but the little I do have shows that all my renderers combined don't take even half of the 1/60s time per frame I need.

The flickering started when I moved away from using a [Scene Graph Under QML](http://doc.qt.io/qt-5/qtquick-scenegraph-openglunderqml-example.html) mixed with Qt3D, towards the threaded FBO example - so I figure there's nothing intrisic in my geometries that should be causing the flickering.